projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Finally added: Temperature limit check on NVidia + Windows to notice User about perfo...
[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 0
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 " --powertune-enable | | Enable power tuning, restores settings when finished |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 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);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 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);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1551
1552 char output_buf[256] = { 0 };
1553
1554 int output_len = 0;
1555
1556 if (num_temperature >= 0)
1557 {
1558 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1559
1560 output_len = strlen (output_buf);
1561 }
1562
1563 if (num_fanspeed >= 0)
1564 {
1565 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1566
1567 output_len = strlen (output_buf);
1568 }
1569
1570 if (num_utilization >= 0)
1571 {
1572 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1573
1574 output_len = strlen (output_buf);
1575 }
1576
1577 if (num_corespeed >= 0)
1578 {
1579 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1580
1581 output_len = strlen (output_buf);
1582 }
1583
1584 if (num_memoryspeed >= 0)
1585 {
1586 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1587
1588 output_len = strlen (output_buf);
1589 }
1590
1591 if (num_buslanes >= 0)
1592 {
1593 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1594
1595 output_len = strlen (output_buf);
1596 }
1597
1598 if (num_throttle == 1)
1599 {
1600 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1601
1602 output_len = strlen (output_buf);
1603 }
1604
1605 if (output_len == 0)
1606 {
1607 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1608
1609 output_len = strlen (output_buf);
1610 }
1611
1612 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1613 }
1614
1615 hc_thread_mutex_unlock (mux_adl);
1616 }
1617 #endif // HAVE_HWMON
1618 }
1619
1620 static void status_benchmark_automate ()
1621 {
1622 u64 speed_cnt[DEVICES_MAX] = { 0 };
1623 double speed_ms[DEVICES_MAX] = { 0 };
1624
1625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1626 {
1627 hc_device_param_t *device_param = &data.devices_param[device_id];
1628
1629 if (device_param->skipped) continue;
1630
1631 speed_cnt[device_id] = device_param->speed_cnt[0];
1632 speed_ms[device_id] = device_param->speed_ms[0];
1633 }
1634
1635 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 hashes_dev_ms[device_id] = 0;
1644
1645 if (speed_ms[device_id])
1646 {
1647 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1648 }
1649 }
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1658 }
1659 }
1660
1661 static void status_benchmark ()
1662 {
1663 if (data.devices_status == STATUS_INIT) return;
1664 if (data.devices_status == STATUS_STARTING) return;
1665 if (data.devices_status == STATUS_BYPASS) return;
1666
1667 if (data.machine_readable == 1)
1668 {
1669 status_benchmark_automate ();
1670
1671 return;
1672 }
1673
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_all_ms = 0;
1688
1689 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 hashes_dev_ms[device_id] = 0;
1698
1699 if (speed_ms[device_id])
1700 {
1701 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1702
1703 hashes_all_ms += hashes_dev_ms[device_id];
1704 }
1705 }
1706
1707 /**
1708 * exec time
1709 */
1710
1711 double exec_all_ms[DEVICES_MAX] = { 0 };
1712
1713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1714 {
1715 hc_device_param_t *device_param = &data.devices_param[device_id];
1716
1717 if (device_param->skipped) continue;
1718
1719 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1720
1721 exec_all_ms[device_id] = exec_ms_avg;
1722 }
1723
1724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1725 {
1726 hc_device_param_t *device_param = &data.devices_param[device_id];
1727
1728 if (device_param->skipped) continue;
1729
1730 char display_dev_cur[16] = { 0 };
1731
1732 strncpy (display_dev_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1735
1736 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1737 }
1738
1739 char display_all_cur[16] = { 0 };
1740
1741 strncpy (display_all_cur, "0.00", 4);
1742
1743 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1744
1745 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1746 }
1747
1748 /**
1749 * hashcat -only- functions
1750 */
1751
1752 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1753 {
1754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1755 {
1756 if (attack_kern == ATTACK_KERN_STRAIGHT)
1757 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1758 else if (attack_kern == ATTACK_KERN_COMBI)
1759 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1760 else if (attack_kern == ATTACK_KERN_BF)
1761 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1762 }
1763 else
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1765 }
1766
1767 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)
1768 {
1769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1770 {
1771 if (attack_kern == ATTACK_KERN_STRAIGHT)
1772 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1773 else if (attack_kern == ATTACK_KERN_COMBI)
1774 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 else if (attack_kern == ATTACK_KERN_BF)
1776 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1785 {
1786 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1789 }
1790 else
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1793 }
1794 }
1795
1796 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)
1797 {
1798 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1801 }
1802 else
1803 {
1804 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1805 }
1806 }
1807
1808 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1811 }
1812
1813 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1814 {
1815 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1816 }
1817
1818 static uint convert_from_hex (char *line_buf, const uint line_len)
1819 {
1820 if (line_len & 1) return (line_len); // not in hex
1821
1822 if (data.hex_wordlist == 1)
1823 {
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836 else if (line_len >= 6) // $HEX[] = 6
1837 {
1838 if (line_buf[0] != '$') return (line_len);
1839 if (line_buf[1] != 'H') return (line_len);
1840 if (line_buf[2] != 'E') return (line_len);
1841 if (line_buf[3] != 'X') return (line_len);
1842 if (line_buf[4] != '[') return (line_len);
1843 if (line_buf[line_len - 1] != ']') return (line_len);
1844
1845 uint i;
1846 uint j;
1847
1848 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1849 {
1850 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1851 }
1852
1853 memset (line_buf + i, 0, line_len - i);
1854
1855 return (i);
1856 }
1857
1858 return (line_len);
1859 }
1860
1861 static void clear_prompt ()
1862 {
1863 fputc ('\r', stdout);
1864
1865 for (size_t i = 0; i < strlen (PROMPT); i++)
1866 {
1867 fputc (' ', stdout);
1868 }
1869
1870 fputc ('\r', stdout);
1871
1872 fflush (stdout);
1873 }
1874
1875 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1876 {
1877 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);
1878 }
1879
1880 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1881 {
1882 char *outfile = data.outfile;
1883 uint quiet = data.quiet;
1884 FILE *pot_fp = data.pot_fp;
1885 uint loopback = data.loopback;
1886 uint debug_mode = data.debug_mode;
1887 char *debug_file = data.debug_file;
1888
1889 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1890 int debug_rule_len = 0; // -1 error
1891 uint debug_plain_len = 0;
1892
1893 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1894
1895 // hash
1896
1897 char out_buf[HCBUFSIZ] = { 0 };
1898
1899 const u32 salt_pos = plain->salt_pos;
1900 const u32 digest_pos = plain->digest_pos; // relative
1901 const u32 gidvid = plain->gidvid;
1902 const u32 il_pos = plain->il_pos;
1903
1904 ascii_digest (out_buf, salt_pos, digest_pos);
1905
1906 // plain
1907
1908 u64 crackpos = device_param->words_off;
1909
1910 uint plain_buf[16] = { 0 };
1911
1912 u8 *plain_ptr = (u8 *) plain_buf;
1913
1914 unsigned int plain_len = 0;
1915
1916 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1917 {
1918 pw_t pw;
1919
1920 gidd_to_pw_t (device_param, gidvid, &pw);
1921
1922 for (int i = 0; i < 16; i++)
1923 {
1924 plain_buf[i] = pw.i[i];
1925 }
1926
1927 plain_len = pw.pw_len;
1928
1929 const uint off = device_param->innerloop_pos + il_pos;
1930
1931 if (debug_mode > 0)
1932 {
1933 debug_rule_len = 0;
1934
1935 // save rule
1936 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1937 {
1938 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1939
1940 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1941 }
1942
1943 // save plain
1944 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1945 {
1946 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1947
1948 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1949
1950 debug_plain_len = plain_len;
1951 }
1952 }
1953
1954 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1955
1956 crackpos += gidvid;
1957 crackpos *= data.kernel_rules_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_COMBI)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidvid, &pw);
2025
2026 for (int i = 0; i < 16; i++)
2027 {
2028 plain_buf[i] = pw.i[i];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2052 {
2053 pw_t pw;
2054
2055 gidd_to_pw_t (device_param, gidvid, &pw);
2056
2057 for (int i = 0; i < 16; i++)
2058 {
2059 plain_buf[i] = pw.i[i];
2060 }
2061
2062 plain_len = pw.pw_len;
2063
2064 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2065
2066 uint start = 0;
2067 uint stop = device_param->kernel_params_mp_buf32[4];
2068
2069 memmove (plain_ptr + stop, plain_ptr, plain_len);
2070
2071 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2072
2073 plain_len += start + stop;
2074
2075 crackpos += gidvid;
2076 crackpos *= data.combs_cnt;
2077 crackpos += device_param->innerloop_pos + il_pos;
2078
2079 if (data.pw_max != PW_DICTMAX1)
2080 {
2081 if (plain_len > data.pw_max) plain_len = data.pw_max;
2082 }
2083 }
2084
2085 if (data.attack_mode == ATTACK_MODE_BF)
2086 {
2087 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2088 {
2089 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2090 {
2091 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2092 {
2093 plain_len = plain_len - data.salts_buf[0].salt_len;
2094 }
2095 }
2096
2097 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2098 {
2099 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2100 {
2101 plain_ptr[j] = plain_ptr[i];
2102 }
2103
2104 plain_len = plain_len / 2;
2105 }
2106 }
2107 }
2108
2109 // if enabled, update also the potfile
2110
2111 if (pot_fp)
2112 {
2113 lock_file (pot_fp);
2114
2115 fprintf (pot_fp, "%s:", out_buf);
2116
2117 format_plain (pot_fp, plain_ptr, plain_len, 1);
2118
2119 fputc ('\n', pot_fp);
2120
2121 fflush (pot_fp);
2122
2123 unlock_file (pot_fp);
2124 }
2125
2126 // outfile
2127
2128 FILE *out_fp = NULL;
2129
2130 if (outfile != NULL)
2131 {
2132 if ((out_fp = fopen (outfile, "ab")) == NULL)
2133 {
2134 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2135
2136 out_fp = stdout;
2137 }
2138
2139 lock_file (out_fp);
2140 }
2141 else
2142 {
2143 out_fp = stdout;
2144
2145 if (quiet == 0) clear_prompt ();
2146 }
2147
2148 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2149
2150 if (outfile != NULL)
2151 {
2152 if (out_fp != stdout)
2153 {
2154 fclose (out_fp);
2155 }
2156 }
2157 else
2158 {
2159 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2160 {
2161 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2162 {
2163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2164 if (quiet == 0) fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 // loopback
2170
2171 if (loopback)
2172 {
2173 char *loopback_file = data.loopback_file;
2174
2175 FILE *fb_fp = NULL;
2176
2177 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2178 {
2179 lock_file (fb_fp);
2180
2181 format_plain (fb_fp, plain_ptr, plain_len, 1);
2182
2183 fputc ('\n', fb_fp);
2184
2185 fclose (fb_fp);
2186 }
2187 }
2188
2189 // (rule) debug mode
2190
2191 // the next check implies that:
2192 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2193 // - debug_mode > 0
2194
2195 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2196 {
2197 if (debug_rule_len < 0) debug_rule_len = 0;
2198
2199 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2200
2201 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2202
2203 if ((quiet == 0) && (debug_file == NULL))
2204 {
2205 fprintf (stdout, "%s", PROMPT);
2206
2207 fflush (stdout);
2208 }
2209 }
2210 }
2211
2212 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2213 {
2214 salt_t *salt_buf = &data.salts_buf[salt_pos];
2215
2216 u32 num_cracked;
2217
2218 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2219
2220 if (num_cracked)
2221 {
2222 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2223
2224 log_info_nn ("");
2225
2226 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2227
2228 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);
2229
2230 uint cpt_cracked = 0;
2231
2232 for (uint i = 0; i < num_cracked; i++)
2233 {
2234 const uint hash_pos = cracked[i].hash_pos;
2235
2236 if (data.digests_shown[hash_pos] == 1) continue;
2237
2238 hc_thread_mutex_lock (mux_display);
2239
2240 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2241 {
2242 data.digests_shown[hash_pos] = 1;
2243
2244 data.digests_done++;
2245
2246 cpt_cracked++;
2247
2248 salt_buf->digests_done++;
2249
2250 if (salt_buf->digests_done == salt_buf->digests_cnt)
2251 {
2252 data.salts_shown[salt_pos] = 1;
2253
2254 data.salts_done++;
2255 }
2256 }
2257
2258 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261
2262 check_hash (device_param, &cracked[i]);
2263 }
2264
2265 myfree (cracked);
2266
2267 if (cpt_cracked > 0)
2268 {
2269 hc_thread_mutex_lock (mux_display);
2270
2271 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2272 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2273
2274 data.cpt_pos++;
2275
2276 data.cpt_total += cpt_cracked;
2277
2278 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281 }
2282
2283 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2284 {
2285 // we need to reset cracked state on the device
2286 // otherwise host thinks again and again the hash was cracked
2287 // and returns invalid password each time
2288
2289 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2290
2291 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);
2292 }
2293
2294 num_cracked = 0;
2295
2296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297 }
2298 }
2299
2300 static void save_hash ()
2301 {
2302 char *hashfile = data.hashfile;
2303
2304 char new_hashfile[256] = { 0 };
2305 char old_hashfile[256] = { 0 };
2306
2307 snprintf (new_hashfile, 255, "%s.new", hashfile);
2308 snprintf (old_hashfile, 255, "%s.old", hashfile);
2309
2310 unlink (new_hashfile);
2311
2312 char separator = data.separator;
2313
2314 FILE *fp = fopen (new_hashfile, "wb");
2315
2316 if (fp == NULL)
2317 {
2318 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2319
2320 exit (-1);
2321 }
2322
2323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2324 {
2325 if (data.salts_shown[salt_pos] == 1) continue;
2326
2327 salt_t *salt_buf = &data.salts_buf[salt_pos];
2328
2329 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2330 {
2331 uint idx = salt_buf->digests_offset + digest_pos;
2332
2333 if (data.digests_shown[idx] == 1) continue;
2334
2335 if (data.hash_mode != 2500)
2336 {
2337 char out_buf[HCBUFSIZ] = { 0 };
2338
2339 if (data.username == 1)
2340 {
2341 user_t *user = data.hash_info[idx]->user;
2342
2343 uint i;
2344
2345 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2346
2347 fputc (separator, fp);
2348 }
2349
2350 ascii_digest (out_buf, salt_pos, digest_pos);
2351
2352 fputs (out_buf, fp);
2353
2354 log_out (fp, "");
2355 }
2356 else
2357 {
2358 hccap_t hccap;
2359
2360 to_hccap_t (&hccap, salt_pos, digest_pos);
2361
2362 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2363 }
2364 }
2365 }
2366
2367 fflush (fp);
2368
2369 fclose (fp);
2370
2371 unlink (old_hashfile);
2372
2373 if (rename (hashfile, old_hashfile) != 0)
2374 {
2375 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2376
2377 exit (-1);
2378 }
2379
2380 unlink (hashfile);
2381
2382 if (rename (new_hashfile, hashfile) != 0)
2383 {
2384 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2385
2386 exit (-1);
2387 }
2388
2389 unlink (old_hashfile);
2390 }
2391
2392 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2393 {
2394 // function called only in case kernel_power_all > words_left
2395
2396 float kernel_power_div = (float) (total_left) / kernel_power_all;
2397
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401
2402 while (kernel_power_new < total_left)
2403 {
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407 }
2408
2409 if (data.quiet == 0)
2410 {
2411 clear_prompt ();
2412
2413 //log_info ("");
2414
2415 log_info ("INFO: approaching final keyspace, workload adjusted");
2416 log_info ("");
2417
2418 fprintf (stdout, "%s", PROMPT);
2419
2420 fflush (stdout);
2421 }
2422
2423 //if ((kernel_power_all * kernel_power_div) < 8) return 1;
2424
2425 return kernel_power_div;
2426 }
2427
2428 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2429 {
2430 uint num_elements = num;
2431
2432 device_param->kernel_params_buf32[30] = data.combs_mode;
2433 device_param->kernel_params_buf32[31] = num;
2434
2435 uint kernel_threads = device_param->kernel_threads;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 cl_kernel kernel = NULL;
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_1: kernel = device_param->kernel1; break;
2444 case KERN_RUN_12: kernel = device_param->kernel12; break;
2445 case KERN_RUN_2: kernel = device_param->kernel2; break;
2446 case KERN_RUN_23: kernel = device_param->kernel23; break;
2447 case KERN_RUN_3: kernel = device_param->kernel3; break;
2448 }
2449
2450 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2451 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2452 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2453 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2454 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2455 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2456 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2457 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2458 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2459 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2460 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2461
2462 cl_event event;
2463
2464 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2465 {
2466 const size_t global_work_size[3] = { num_elements, 32, 1 };
2467 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2470 }
2471 else
2472 {
2473 if (kern_run == KERN_RUN_2)
2474 {
2475 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2476 {
2477 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2478 }
2479 }
2480
2481 while (num_elements % kernel_threads) num_elements++;
2482
2483 const size_t global_work_size[3] = { num_elements, 1, 1 };
2484 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2485
2486 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2487 }
2488
2489 hc_clFlush (data.ocl, device_param->command_queue);
2490
2491 hc_clWaitForEvents (data.ocl, 1, &event);
2492
2493 if (event_update)
2494 {
2495 cl_ulong time_start;
2496 cl_ulong time_end;
2497
2498 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2499 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2500
2501 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2502
2503 uint exec_pos = device_param->exec_pos;
2504
2505 device_param->exec_ms[exec_pos] = exec_time;
2506
2507 exec_pos++;
2508
2509 if (exec_pos == EXEC_CACHE)
2510 {
2511 exec_pos = 0;
2512 }
2513
2514 device_param->exec_pos = exec_pos;
2515 }
2516
2517 hc_clReleaseEvent (data.ocl, event);
2518
2519 hc_clFinish (data.ocl, device_param->command_queue);
2520 }
2521
2522 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2523 {
2524 uint num_elements = num;
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2529 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2530 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2531 }
2532
2533 // causes problems with special threads like in bcrypt
2534 // const uint kernel_threads = device_param->kernel_threads;
2535
2536 uint kernel_threads = device_param->kernel_threads;
2537
2538 while (num_elements % kernel_threads) num_elements++;
2539
2540 cl_kernel kernel = NULL;
2541
2542 switch (kern_run)
2543 {
2544 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2545 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2546 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2547 }
2548
2549 switch (kern_run)
2550 {
2551 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2552 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2553 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2554 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2555 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2556 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2557 break;
2558 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2559 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2560 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2561 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2562 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2563 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2564 break;
2565 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2566 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2567 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2568 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2569 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2570 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2571 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2572 break;
2573 }
2574
2575 const size_t global_work_size[3] = { num_elements, 1, 1 };
2576 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2577
2578 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2579
2580 hc_clFlush (data.ocl, device_param->command_queue);
2581
2582 hc_clFinish (data.ocl, device_param->command_queue);
2583 }
2584
2585 static void run_kernel_tm (hc_device_param_t *device_param)
2586 {
2587 const uint num_elements = 1024; // fixed
2588
2589 uint kernel_threads = 32;
2590
2591 cl_kernel kernel = device_param->kernel_tm;
2592
2593 const size_t global_work_size[3] = { num_elements, 1, 1 };
2594 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2595
2596 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2597
2598 hc_clFlush (data.ocl, device_param->command_queue);
2599
2600 hc_clFinish (data.ocl, device_param->command_queue);
2601 }
2602
2603 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2608 device_param->kernel_params_amp_buf32[6] = num_elements;
2609
2610 // causes problems with special threads like in bcrypt
2611 // const uint kernel_threads = device_param->kernel_threads;
2612
2613 uint kernel_threads = device_param->kernel_threads;
2614
2615 while (num_elements % kernel_threads) num_elements++;
2616
2617 cl_kernel kernel = device_param->kernel_amp;
2618
2619 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2620 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2621
2622 const size_t global_work_size[3] = { num_elements, 1, 1 };
2623 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2624
2625 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2626
2627 hc_clFlush (data.ocl, device_param->command_queue);
2628
2629 hc_clFinish (data.ocl, device_param->command_queue);
2630 }
2631
2632 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2633 {
2634 const u32 num16d = num / 16;
2635 const u32 num16m = num % 16;
2636
2637 if (num16d)
2638 {
2639 device_param->kernel_params_memset_buf32[1] = value;
2640 device_param->kernel_params_memset_buf32[2] = num16d;
2641
2642 uint kernel_threads = device_param->kernel_threads;
2643
2644 uint num_elements = num16d;
2645
2646 while (num_elements % kernel_threads) num_elements++;
2647
2648 cl_kernel kernel = device_param->kernel_memset;
2649
2650 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2651 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2652 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2653
2654 const size_t global_work_size[3] = { num_elements, 1, 1 };
2655 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2656
2657 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2658
2659 hc_clFlush (data.ocl, device_param->command_queue);
2660
2661 hc_clFinish (data.ocl, device_param->command_queue);
2662 }
2663
2664 if (num16m)
2665 {
2666 u32 tmp[4];
2667
2668 tmp[0] = value;
2669 tmp[1] = value;
2670 tmp[2] = value;
2671 tmp[3] = value;
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2674 }
2675 }
2676
2677 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2678 {
2679 run_kernel_memset (device_param, buf, 0, size);
2680
2681 /*
2682 int rc = -1;
2683
2684 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2685 {
2686 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2687
2688 const cl_uchar zero = 0;
2689
2690 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2691 }
2692
2693 if (rc != 0)
2694 {
2695 // NOTE: clEnqueueFillBuffer () always fails with -59
2696 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2697 // How's that possible, OpenCL 1.2 support is advertised??
2698 // We need to workaround...
2699
2700 #define FILLSZ 0x100000
2701
2702 char *tmp = (char *) mymalloc (FILLSZ);
2703
2704 for (size_t i = 0; i < size; i += FILLSZ)
2705 {
2706 const size_t left = size - i;
2707
2708 const size_t fillsz = MIN (FILLSZ, left);
2709
2710 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2711 }
2712
2713 myfree (tmp);
2714 }
2715 */
2716 }
2717
2718 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)
2719 {
2720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2721 {
2722 if (attack_mode == ATTACK_MODE_BF)
2723 {
2724 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2725 {
2726 const uint size_tm = 32 * sizeof (bs_word_t);
2727
2728 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2729
2730 run_kernel_tm (device_param);
2731
2732 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);
2733 }
2734 }
2735
2736 if (highest_pw_len < 16)
2737 {
2738 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2739 }
2740 else if (highest_pw_len < 32)
2741 {
2742 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2743 }
2744 else
2745 {
2746 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2747 }
2748 }
2749 else
2750 {
2751 run_kernel_amp (device_param, pws_cnt);
2752
2753 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2754
2755 if (opts_type & OPTS_TYPE_HOOK12)
2756 {
2757 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2758 }
2759
2760 uint iter = salt_buf->salt_iter;
2761
2762 uint loop_step = device_param->kernel_loops;
2763
2764 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2765 {
2766 uint loop_left = iter - loop_pos;
2767
2768 loop_left = MIN (loop_left, loop_step);
2769
2770 device_param->kernel_params_buf32[25] = loop_pos;
2771 device_param->kernel_params_buf32[26] = loop_left;
2772
2773 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2774
2775 if (data.devices_status == STATUS_CRACKED) break;
2776 if (data.devices_status == STATUS_ABORTED) break;
2777 if (data.devices_status == STATUS_QUIT) break;
2778
2779 /**
2780 * speed
2781 */
2782
2783 const float iter_part = (float) (loop_pos + loop_left) / iter;
2784
2785 const u64 perf_sum_all = pws_cnt * iter_part;
2786
2787 double speed_ms;
2788
2789 hc_timer_get (device_param->timer_speed, speed_ms);
2790
2791 const u32 speed_pos = device_param->speed_pos;
2792
2793 device_param->speed_cnt[speed_pos] = perf_sum_all;
2794
2795 device_param->speed_ms[speed_pos] = speed_ms;
2796
2797 if (data.benchmark == 1)
2798 {
2799 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2800 }
2801 }
2802
2803 if (opts_type & OPTS_TYPE_HOOK23)
2804 {
2805 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2806
2807 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);
2808
2809 // do something with data
2810
2811 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);
2812 }
2813
2814 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2815 }
2816 }
2817
2818 static int run_rule_engine (const int rule_len, const char *rule_buf)
2819 {
2820 if (rule_len == 0)
2821 {
2822 return 0;
2823 }
2824 else if (rule_len == 1)
2825 {
2826 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2827 }
2828
2829 return 1;
2830 }
2831
2832 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2833 {
2834 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2835 {
2836 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);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_COMBI)
2839 {
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2843 {
2844 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2845 {
2846 for (u32 i = 0; i < pws_cnt; i++)
2847 {
2848 const u32 pw_len = device_param->pws_buf[i].pw_len;
2849
2850 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2851
2852 ptr[pw_len] = 0x01;
2853 }
2854 }
2855 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2856 {
2857 for (u32 i = 0; i < pws_cnt; i++)
2858 {
2859 const u32 pw_len = device_param->pws_buf[i].pw_len;
2860
2861 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2862
2863 ptr[pw_len] = 0x80;
2864 }
2865 }
2866 }
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2869 {
2870 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2871 {
2872 for (u32 i = 0; i < pws_cnt; i++)
2873 {
2874 const u32 pw_len = device_param->pws_buf[i].pw_len;
2875
2876 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2877
2878 ptr[pw_len] = 0x01;
2879 }
2880 }
2881 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2882 {
2883 for (u32 i = 0; i < pws_cnt; i++)
2884 {
2885 const u32 pw_len = device_param->pws_buf[i].pw_len;
2886
2887 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2888
2889 ptr[pw_len] = 0x80;
2890 }
2891 }
2892 }
2893
2894 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);
2895 }
2896 else if (data.attack_kern == ATTACK_KERN_BF)
2897 {
2898 const u64 off = device_param->words_off;
2899
2900 device_param->kernel_params_mp_l_buf64[3] = off;
2901
2902 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2903 }
2904 }
2905
2906 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2907 {
2908 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2909
2910 device_param->kernel_params_buf32[25] = 0;
2911 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2912 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2913
2914 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2915 {
2916 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2917 }
2918 else
2919 {
2920 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2921 }
2922
2923 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2924
2925 return exec_ms_prev;
2926 }
2927
2928 static void autotune (hc_device_param_t *device_param)
2929 {
2930 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2931
2932 const u32 kernel_accel_min = device_param->kernel_accel_min;
2933 const u32 kernel_accel_max = device_param->kernel_accel_max;
2934
2935 const u32 kernel_loops_min = device_param->kernel_loops_min;
2936 const u32 kernel_loops_max = device_param->kernel_loops_max;
2937
2938 u32 kernel_accel = kernel_accel_min;
2939 u32 kernel_loops = kernel_loops_min;
2940
2941 // in this case the user specified a fixed -u and -n on the commandline
2942 // no way to tune anything
2943 // but we need to run a few caching rounds
2944
2945 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2946 {
2947 try_run (device_param, kernel_accel, kernel_loops);
2948 try_run (device_param, kernel_accel, kernel_loops);
2949 try_run (device_param, kernel_accel, kernel_loops);
2950 try_run (device_param, kernel_accel, kernel_loops);
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 return;
2960 }
2961
2962 // from here it's clear we are allowed to autotune
2963 // so let's init some fake words
2964
2965 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2966
2967 if (data.attack_kern == ATTACK_KERN_BF)
2968 {
2969 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2970 }
2971 else
2972 {
2973 for (u32 i = 0; i < kernel_power_max; i++)
2974 {
2975 device_param->pws_buf[i].i[0] = i;
2976 device_param->pws_buf[i].i[1] = 0x01234567;
2977 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2978 }
2979
2980 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);
2981 }
2982
2983 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2984 {
2985 if (data.kernel_rules_cnt > 1)
2986 {
2987 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
2988 }
2989 }
2990 else
2991 {
2992 run_kernel_amp (device_param, kernel_power_max);
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
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 int temp_threshold = 1; // degrees celcius
3833
3834 int fan_speed_min = 15; // in percentage
3835 int fan_speed_max = 100;
3836
3837 time_t last_temp_check_time;
3838 #endif // HAVE_HWMON
3839
3840 uint sleep_time = 1;
3841
3842 if (data.runtime)
3843 {
3844 runtime_check = 1;
3845 }
3846
3847 if (data.restore_timer)
3848 {
3849 restore_check = 1;
3850 }
3851
3852 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3853 {
3854 remove_check = 1;
3855 }
3856
3857 if (data.status == 1)
3858 {
3859 status_check = 1;
3860 }
3861
3862 #ifdef HAVE_HWMON
3863 if (data.gpu_temp_disable == 0)
3864 {
3865 time (&last_temp_check_time);
3866
3867 hwmon_check = 1;
3868 }
3869 #endif
3870
3871 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3872 {
3873 #ifdef HAVE_HWMON
3874 if (hwmon_check == 0)
3875 #endif
3876 return (p);
3877 }
3878
3879 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3880 {
3881 hc_sleep (sleep_time);
3882
3883 if (data.devices_status != STATUS_RUNNING) continue;
3884
3885 #ifdef HAVE_HWMON
3886
3887 if (hwmon_check == 1)
3888 {
3889 hc_thread_mutex_lock (mux_adl);
3890
3891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3892 {
3893 hc_device_param_t *device_param = &data.devices_param[device_id];
3894
3895 if (device_param->skipped) continue;
3896
3897 if (device_param->device_vendor_id == VENDOR_ID_NV)
3898 {
3899 if (data.hm_nvapi)
3900 {
3901 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3902 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3903
3904 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3905 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3906
3907 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3908
3909 perfPolicies_status.info_value = perfPolicies_info.info_value;
3910
3911 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3912
3913 if (perfPolicies_status.throttle & 2)
3914 {
3915 if (slowdown_warnings < 3)
3916 {
3917 if (data.quiet == 0) clear_prompt ();
3918
3919 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3920
3921 if (slowdown_warnings == 2)
3922 {
3923 log_info ("");
3924 }
3925
3926 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3927 if (data.quiet == 0) fflush (stdout);
3928
3929 slowdown_warnings++;
3930 }
3931 }
3932 else
3933 {
3934 slowdown_warnings = 0;
3935 }
3936 }
3937 }
3938 }
3939
3940 hc_thread_mutex_unlock (mux_adl);
3941 }
3942
3943 if (hwmon_check == 1)
3944 {
3945 hc_thread_mutex_lock (mux_adl);
3946
3947 time_t temp_check_time;
3948
3949 time (&temp_check_time);
3950
3951 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3952
3953 if (Ta == 0) Ta = 1;
3954
3955 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3956 {
3957 hc_device_param_t *device_param = &data.devices_param[device_id];
3958
3959 if (device_param->skipped) continue;
3960
3961 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3962
3963 const int temperature = hm_get_temperature_with_device_id (device_id);
3964
3965 if (temperature > (int) data.gpu_temp_abort)
3966 {
3967 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3968
3969 if (data.devices_status != STATUS_QUIT) myabort ();
3970
3971 break;
3972 }
3973
3974 const int gpu_temp_retain = data.gpu_temp_retain;
3975
3976 if (gpu_temp_retain)
3977 {
3978 if (data.hm_device[device_id].fan_set_supported == 1)
3979 {
3980 int temp_cur = temperature;
3981
3982 int temp_diff_new = gpu_temp_retain - temp_cur;
3983
3984 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3985
3986 // calculate Ta value (time difference in seconds between the last check and this check)
3987
3988 last_temp_check_time = temp_check_time;
3989
3990 float Kp = 1.8;
3991 float Ki = 0.005;
3992 float Kd = 6;
3993
3994 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3995
3996 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);
3997
3998 if (abs (fan_diff_required) >= temp_threshold)
3999 {
4000 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4001
4002 int fan_speed_level = fan_speed_cur;
4003
4004 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4005
4006 int fan_speed_new = fan_speed_level - fan_diff_required;
4007
4008 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4009 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4010
4011 if (fan_speed_new != fan_speed_cur)
4012 {
4013 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4014 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4015
4016 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4017 {
4018 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4019 {
4020 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4021 }
4022 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4023 {
4024
4025 }
4026
4027 fan_speed_chgd[device_id] = 1;
4028 }
4029
4030 temp_diff_old[device_id] = temp_diff_new;
4031 }
4032 }
4033 }
4034 }
4035 }
4036
4037 hc_thread_mutex_unlock (mux_adl);
4038 }
4039 #endif // HAVE_HWMON
4040
4041 if (restore_check == 1)
4042 {
4043 restore_left--;
4044
4045 if (restore_left == 0)
4046 {
4047 if (data.restore_disable == 0) cycle_restore ();
4048
4049 restore_left = data.restore_timer;
4050 }
4051 }
4052
4053 if ((runtime_check == 1) && (data.runtime_start > 0))
4054 {
4055 time_t runtime_cur;
4056
4057 time (&runtime_cur);
4058
4059 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4060
4061 if (runtime_left <= 0)
4062 {
4063 if (data.benchmark == 0)
4064 {
4065 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4066 }
4067
4068 if (data.devices_status != STATUS_QUIT) myabort ();
4069 }
4070 }
4071
4072 if (remove_check == 1)
4073 {
4074 remove_left--;
4075
4076 if (remove_left == 0)
4077 {
4078 if (data.digests_saved != data.digests_done)
4079 {
4080 data.digests_saved = data.digests_done;
4081
4082 save_hash ();
4083 }
4084
4085 remove_left = data.remove_timer;
4086 }
4087 }
4088
4089 if (status_check == 1)
4090 {
4091 status_left--;
4092
4093 if (status_left == 0)
4094 {
4095 //hc_thread_mutex_lock (mux_display);
4096
4097 if (data.quiet == 0) clear_prompt ();
4098
4099 if (data.quiet == 0) log_info ("");
4100
4101 status_display ();
4102
4103 if (data.quiet == 0) log_info ("");
4104
4105 //hc_thread_mutex_unlock (mux_display);
4106
4107 status_left = data.status_timer;
4108 }
4109 }
4110 }
4111
4112 #ifdef HAVE_HWMON
4113 myfree (fan_speed_chgd);
4114
4115 myfree (temp_diff_old);
4116 myfree (temp_diff_sum);
4117 #endif
4118
4119 p = NULL;
4120
4121 return (p);
4122 }
4123
4124 static void *thread_outfile_remove (void *p)
4125 {
4126 // some hash-dependent constants
4127 char *outfile_dir = data.outfile_check_directory;
4128 uint dgst_size = data.dgst_size;
4129 uint isSalted = data.isSalted;
4130 uint esalt_size = data.esalt_size;
4131 uint hash_mode = data.hash_mode;
4132
4133 uint outfile_check_timer = data.outfile_check_timer;
4134
4135 char separator = data.separator;
4136
4137 // some hash-dependent functions
4138 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4139 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4140
4141 // buffers
4142 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4143
4144 hash_buf.digest = mymalloc (dgst_size);
4145
4146 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4147
4148 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4149
4150 uint digest_buf[64] = { 0 };
4151
4152 outfile_data_t *out_info = NULL;
4153
4154 char **out_files = NULL;
4155
4156 time_t folder_mtime = 0;
4157
4158 int out_cnt = 0;
4159
4160 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4161
4162 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4163 {
4164 hc_sleep (1);
4165
4166 if (data.devices_status != STATUS_RUNNING) continue;
4167
4168 check_left--;
4169
4170 if (check_left == 0)
4171 {
4172 struct stat outfile_check_stat;
4173
4174 if (stat (outfile_dir, &outfile_check_stat) == 0)
4175 {
4176 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4177
4178 if (is_dir == 1)
4179 {
4180 if (outfile_check_stat.st_mtime > folder_mtime)
4181 {
4182 char **out_files_new = scan_directory (outfile_dir);
4183
4184 int out_cnt_new = count_dictionaries (out_files_new);
4185
4186 outfile_data_t *out_info_new = NULL;
4187
4188 if (out_cnt_new > 0)
4189 {
4190 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4191
4192 for (int i = 0; i < out_cnt_new; i++)
4193 {
4194 out_info_new[i].file_name = out_files_new[i];
4195
4196 // check if there are files that we have seen/checked before (and not changed)
4197
4198 for (int j = 0; j < out_cnt; j++)
4199 {
4200 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4201 {
4202 struct stat outfile_stat;
4203
4204 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4205 {
4206 if (outfile_stat.st_ctime == out_info[j].ctime)
4207 {
4208 out_info_new[i].ctime = out_info[j].ctime;
4209 out_info_new[i].seek = out_info[j].seek;
4210 }
4211 }
4212 }
4213 }
4214 }
4215 }
4216
4217 local_free (out_info);
4218 local_free (out_files);
4219
4220 out_files = out_files_new;
4221 out_cnt = out_cnt_new;
4222 out_info = out_info_new;
4223
4224 folder_mtime = outfile_check_stat.st_mtime;
4225 }
4226
4227 for (int j = 0; j < out_cnt; j++)
4228 {
4229 FILE *fp = fopen (out_info[j].file_name, "rb");
4230
4231 if (fp != NULL)
4232 {
4233 //hc_thread_mutex_lock (mux_display);
4234
4235 #ifdef _POSIX
4236 struct stat outfile_stat;
4237
4238 fstat (fileno (fp), &outfile_stat);
4239 #endif
4240
4241 #ifdef _WIN
4242 struct stat64 outfile_stat;
4243
4244 _fstat64 (fileno (fp), &outfile_stat);
4245 #endif
4246
4247 if (outfile_stat.st_ctime > out_info[j].ctime)
4248 {
4249 out_info[j].ctime = outfile_stat.st_ctime;
4250 out_info[j].seek = 0;
4251 }
4252
4253 fseek (fp, out_info[j].seek, SEEK_SET);
4254
4255 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4256
4257 while (!feof (fp))
4258 {
4259 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4260
4261 if (ptr == NULL) break;
4262
4263 int line_len = strlen (line_buf);
4264
4265 if (line_len <= 0) continue;
4266
4267 int iter = MAX_CUT_TRIES;
4268
4269 for (uint i = line_len - 1; i && iter; i--, line_len--)
4270 {
4271 if (line_buf[i] != separator) continue;
4272
4273 int parser_status = PARSER_OK;
4274
4275 if ((hash_mode != 2500) && (hash_mode != 6800))
4276 {
4277 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4278 }
4279
4280 uint found = 0;
4281
4282 if (parser_status == PARSER_OK)
4283 {
4284 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4285 {
4286 if (data.salts_shown[salt_pos] == 1) continue;
4287
4288 salt_t *salt_buf = &data.salts_buf[salt_pos];
4289
4290 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4291 {
4292 uint idx = salt_buf->digests_offset + digest_pos;
4293
4294 if (data.digests_shown[idx] == 1) continue;
4295
4296 uint cracked = 0;
4297
4298 if (hash_mode == 6800)
4299 {
4300 if (i == salt_buf->salt_len)
4301 {
4302 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4303 }
4304 }
4305 else if (hash_mode == 2500)
4306 {
4307 // BSSID : MAC1 : MAC2 (:plain)
4308 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4309 {
4310 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4311
4312 if (!cracked) continue;
4313
4314 // now compare MAC1 and MAC2 too, since we have this additional info
4315 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4316 char *mac2_pos = mac1_pos + 12 + 1;
4317
4318 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4319 wpa_t *wpa = &wpas[salt_pos];
4320
4321 // compare hex string(s) vs binary MAC address(es)
4322
4323 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4324 {
4325 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4326 {
4327 cracked = 0;
4328
4329 break;
4330 }
4331 }
4332
4333 // early skip ;)
4334 if (!cracked) continue;
4335
4336 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4337 {
4338 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4339 {
4340 cracked = 0;
4341
4342 break;
4343 }
4344 }
4345 }
4346 }
4347 else
4348 {
4349 char *digests_buf_ptr = (char *) data.digests_buf;
4350
4351 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4352
4353 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4354 }
4355
4356 if (cracked == 1)
4357 {
4358 found = 1;
4359
4360 data.digests_shown[idx] = 1;
4361
4362 data.digests_done++;
4363
4364 salt_buf->digests_done++;
4365
4366 if (salt_buf->digests_done == salt_buf->digests_cnt)
4367 {
4368 data.salts_shown[salt_pos] = 1;
4369
4370 data.salts_done++;
4371
4372 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4373 }
4374 }
4375 }
4376
4377 if (data.devices_status == STATUS_CRACKED) break;
4378 }
4379 }
4380
4381 if (found) break;
4382
4383 if (data.devices_status == STATUS_CRACKED) break;
4384
4385 iter--;
4386 }
4387
4388 if (data.devices_status == STATUS_CRACKED) break;
4389 }
4390
4391 myfree (line_buf);
4392
4393 out_info[j].seek = ftell (fp);
4394
4395 //hc_thread_mutex_unlock (mux_display);
4396
4397 fclose (fp);
4398 }
4399 }
4400 }
4401 }
4402
4403 check_left = outfile_check_timer;
4404 }
4405 }
4406
4407 if (esalt_size) local_free (hash_buf.esalt);
4408
4409 if (isSalted) local_free (hash_buf.salt);
4410
4411 local_free (hash_buf.digest);
4412
4413 local_free (out_info);
4414
4415 local_free (out_files);
4416
4417 p = NULL;
4418
4419 return (p);
4420 }
4421
4422 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4423 {
4424 //if (device_param->pws_cnt < device_param->kernel_power)
4425 //{
4426 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4427
4428 u8 *ptr = (u8 *) pw->i;
4429
4430 memcpy (ptr, pw_buf, pw_len);
4431
4432 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4433
4434 pw->pw_len = pw_len;
4435
4436 device_param->pws_cnt++;
4437 //}
4438 //else
4439 //{
4440 // fprintf (stderr, "BUG pw_add()!!\n");
4441 //
4442 // return;
4443 //}
4444 }
4445
4446 static u32 get_power (const u32 kernel_power)
4447 {
4448 if (data.kernel_power_div)
4449 {
4450 return (float) kernel_power * data.kernel_power_div;
4451 }
4452
4453 return kernel_power;
4454 }
4455
4456 static uint get_work (hc_device_param_t *device_param, const u64 max)
4457 {
4458 hc_thread_mutex_lock (mux_dispatcher);
4459
4460 const u64 words_cur = data.words_cur;
4461 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4462
4463 device_param->words_off = words_cur;
4464
4465 const u64 words_left = words_base - words_cur;
4466
4467 if (data.kernel_power_all > words_left)
4468 {
4469 if (data.kernel_power_div == 0)
4470 {
4471 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4472 }
4473 }
4474
4475 const u32 kernel_power = get_power (device_param->kernel_power);
4476
4477 uint work = MIN (words_left, kernel_power);
4478
4479 work = MIN (work, max);
4480
4481 data.words_cur += work;
4482
4483 hc_thread_mutex_unlock (mux_dispatcher);
4484
4485 return work;
4486 }
4487
4488 static void *thread_autotune (void *p)
4489 {
4490 hc_device_param_t *device_param = (hc_device_param_t *) p;
4491
4492 if (device_param->skipped) return NULL;
4493
4494 autotune (device_param);
4495
4496 return NULL;
4497 }
4498
4499 static void *thread_calc_stdin (void *p)
4500 {
4501 hc_device_param_t *device_param = (hc_device_param_t *) p;
4502
4503 if (device_param->skipped) return NULL;
4504
4505 char *buf = (char *) mymalloc (HCBUFSIZ);
4506
4507 const uint attack_kern = data.attack_kern;
4508
4509 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4510 {
4511 hc_thread_mutex_lock (mux_dispatcher);
4512
4513 if (feof (stdin) != 0)
4514 {
4515 hc_thread_mutex_unlock (mux_dispatcher);
4516
4517 break;
4518 }
4519
4520 uint words_cur = 0;
4521
4522 while (words_cur < get_power (device_param->kernel_power))
4523 {
4524 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4525
4526 if (line_buf == NULL) break;
4527
4528 uint line_len = in_superchop (line_buf);
4529
4530 line_len = convert_from_hex (line_buf, line_len);
4531
4532 // post-process rule engine
4533
4534 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4535 {
4536 char rule_buf_out[BLOCK_SIZE] = { 0 };
4537
4538 int rule_len_out = -1;
4539
4540 if (line_len < BLOCK_SIZE)
4541 {
4542 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4543 }
4544
4545 if (rule_len_out < 0) continue;
4546
4547 line_buf = rule_buf_out;
4548 line_len = rule_len_out;
4549 }
4550
4551 if (line_len > PW_MAX)
4552 {
4553 continue;
4554 }
4555
4556 if (attack_kern == ATTACK_KERN_STRAIGHT)
4557 {
4558 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4559 {
4560 hc_thread_mutex_lock (mux_counter);
4561
4562 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4563 {
4564 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4565 }
4566
4567 hc_thread_mutex_unlock (mux_counter);
4568
4569 continue;
4570 }
4571 }
4572 else if (attack_kern == ATTACK_KERN_COMBI)
4573 {
4574 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4575 // since we still need to combine the plains
4576
4577 if (line_len > data.pw_max)
4578 {
4579 hc_thread_mutex_lock (mux_counter);
4580
4581 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4582 {
4583 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4584 }
4585
4586 hc_thread_mutex_unlock (mux_counter);
4587
4588 continue;
4589 }
4590 }
4591
4592 pw_add (device_param, (u8 *) line_buf, line_len);
4593
4594 words_cur++;
4595
4596 if (data.devices_status == STATUS_CRACKED) break;
4597 if (data.devices_status == STATUS_ABORTED) break;
4598 if (data.devices_status == STATUS_QUIT) break;
4599 if (data.devices_status == STATUS_BYPASS) break;
4600 }
4601
4602 hc_thread_mutex_unlock (mux_dispatcher);
4603
4604 if (data.devices_status == STATUS_CRACKED) break;
4605 if (data.devices_status == STATUS_ABORTED) break;
4606 if (data.devices_status == STATUS_QUIT) break;
4607 if (data.devices_status == STATUS_BYPASS) break;
4608
4609 // flush
4610
4611 const uint pws_cnt = device_param->pws_cnt;
4612
4613 if (pws_cnt)
4614 {
4615 run_copy (device_param, pws_cnt);
4616
4617 run_cracker (device_param, pws_cnt);
4618
4619 device_param->pws_cnt = 0;
4620
4621 /*
4622 still required?
4623 if (attack_kern == ATTACK_KERN_STRAIGHT)
4624 {
4625 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4626 }
4627 else if (attack_kern == ATTACK_KERN_COMBI)
4628 {
4629 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4630 }
4631 */
4632 }
4633 }
4634
4635 device_param->kernel_accel = 0;
4636 device_param->kernel_loops = 0;
4637
4638 myfree (buf);
4639
4640 return NULL;
4641 }
4642
4643 static void *thread_calc (void *p)
4644 {
4645 hc_device_param_t *device_param = (hc_device_param_t *) p;
4646
4647 if (device_param->skipped) return NULL;
4648
4649 const uint attack_mode = data.attack_mode;
4650 const uint attack_kern = data.attack_kern;
4651
4652 if (attack_mode == ATTACK_MODE_BF)
4653 {
4654 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4655 {
4656 const uint work = get_work (device_param, -1);
4657
4658 if (work == 0) break;
4659
4660 const u64 words_off = device_param->words_off;
4661 const u64 words_fin = words_off + work;
4662
4663 const uint pws_cnt = work;
4664
4665 device_param->pws_cnt = pws_cnt;
4666
4667 if (pws_cnt)
4668 {
4669 run_copy (device_param, pws_cnt);
4670
4671 run_cracker (device_param, pws_cnt);
4672
4673 device_param->pws_cnt = 0;
4674
4675 /*
4676 still required?
4677 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4678 */
4679 }
4680
4681 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4682
4683 if (data.devices_status == STATUS_CRACKED) break;
4684 if (data.devices_status == STATUS_ABORTED) break;
4685 if (data.devices_status == STATUS_QUIT) break;
4686 if (data.devices_status == STATUS_BYPASS) break;
4687
4688 if (data.benchmark == 1) break;
4689
4690 device_param->words_done = words_fin;
4691 }
4692 }
4693 else
4694 {
4695 const uint segment_size = data.segment_size;
4696
4697 char *dictfile = data.dictfile;
4698
4699 if (attack_mode == ATTACK_MODE_COMBI)
4700 {
4701 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4702 {
4703 dictfile = data.dictfile2;
4704 }
4705 }
4706
4707 FILE *fd = fopen (dictfile, "rb");
4708
4709 if (fd == NULL)
4710 {
4711 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4712
4713 return NULL;
4714 }
4715
4716 if (attack_mode == ATTACK_MODE_COMBI)
4717 {
4718 const uint combs_mode = data.combs_mode;
4719
4720 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4721 {
4722 const char *dictfilec = data.dictfile2;
4723
4724 FILE *combs_fp = fopen (dictfilec, "rb");
4725
4726 if (combs_fp == NULL)
4727 {
4728 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4729
4730 fclose (fd);
4731
4732 return NULL;
4733 }
4734
4735 device_param->combs_fp = combs_fp;
4736 }
4737 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4738 {
4739 const char *dictfilec = data.dictfile;
4740
4741 FILE *combs_fp = fopen (dictfilec, "rb");
4742
4743 if (combs_fp == NULL)
4744 {
4745 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4746
4747 fclose (fd);
4748
4749 return NULL;
4750 }
4751
4752 device_param->combs_fp = combs_fp;
4753 }
4754 }
4755
4756 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4757
4758 wl_data->buf = (char *) mymalloc (segment_size);
4759 wl_data->avail = segment_size;
4760 wl_data->incr = segment_size;
4761 wl_data->cnt = 0;
4762 wl_data->pos = 0;
4763
4764 u64 words_cur = 0;
4765
4766 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4767 {
4768 u64 words_off = 0;
4769 u64 words_fin = 0;
4770
4771 u64 max = -1;
4772
4773 while (max)
4774 {
4775 const uint work = get_work (device_param, max);
4776
4777 if (work == 0) break;
4778
4779 max = 0;
4780
4781 words_off = device_param->words_off;
4782 words_fin = words_off + work;
4783
4784 char *line_buf;
4785 uint line_len;
4786
4787 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4788
4789 for ( ; words_cur < words_fin; words_cur++)
4790 {
4791 get_next_word (wl_data, fd, &line_buf, &line_len);
4792
4793 line_len = convert_from_hex (line_buf, line_len);
4794
4795 // post-process rule engine
4796
4797 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4798 {
4799 char rule_buf_out[BLOCK_SIZE] = { 0 };
4800
4801 int rule_len_out = -1;
4802
4803 if (line_len < BLOCK_SIZE)
4804 {
4805 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4806 }
4807
4808 if (rule_len_out < 0) continue;
4809
4810 line_buf = rule_buf_out;
4811 line_len = rule_len_out;
4812 }
4813
4814 if (attack_kern == ATTACK_KERN_STRAIGHT)
4815 {
4816 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4817 {
4818 max++;
4819
4820 hc_thread_mutex_lock (mux_counter);
4821
4822 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4823 {
4824 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4825 }
4826
4827 hc_thread_mutex_unlock (mux_counter);
4828
4829 continue;
4830 }
4831 }
4832 else if (attack_kern == ATTACK_KERN_COMBI)
4833 {
4834 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4835 // since we still need to combine the plains
4836
4837 if (line_len > data.pw_max)
4838 {
4839 max++;
4840
4841 hc_thread_mutex_lock (mux_counter);
4842
4843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4844 {
4845 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4846 }
4847
4848 hc_thread_mutex_unlock (mux_counter);
4849
4850 continue;
4851 }
4852 }
4853
4854 pw_add (device_param, (u8 *) line_buf, line_len);
4855
4856 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4857
4858 if (data.devices_status == STATUS_CRACKED) break;
4859 if (data.devices_status == STATUS_ABORTED) break;
4860 if (data.devices_status == STATUS_QUIT) break;
4861 if (data.devices_status == STATUS_BYPASS) break;
4862 }
4863
4864 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4865
4866 if (data.devices_status == STATUS_CRACKED) break;
4867 if (data.devices_status == STATUS_ABORTED) break;
4868 if (data.devices_status == STATUS_QUIT) break;
4869 if (data.devices_status == STATUS_BYPASS) break;
4870 }
4871
4872 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4873
4874 if (data.devices_status == STATUS_CRACKED) break;
4875 if (data.devices_status == STATUS_ABORTED) break;
4876 if (data.devices_status == STATUS_QUIT) break;
4877 if (data.devices_status == STATUS_BYPASS) break;
4878
4879 //
4880 // flush
4881 //
4882
4883 const uint pws_cnt = device_param->pws_cnt;
4884
4885 if (pws_cnt)
4886 {
4887 run_copy (device_param, pws_cnt);
4888
4889 run_cracker (device_param, pws_cnt);
4890
4891 device_param->pws_cnt = 0;
4892
4893 /*
4894 still required?
4895 if (attack_kern == ATTACK_KERN_STRAIGHT)
4896 {
4897 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4898 }
4899 else if (attack_kern == ATTACK_KERN_COMBI)
4900 {
4901 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4902 }
4903 */
4904 }
4905
4906 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4907
4908 if (data.devices_status == STATUS_CRACKED) break;
4909 if (data.devices_status == STATUS_ABORTED) break;
4910 if (data.devices_status == STATUS_QUIT) break;
4911 if (data.devices_status == STATUS_BYPASS) break;
4912
4913 if (words_fin == 0) break;
4914
4915 device_param->words_done = words_fin;
4916 }
4917
4918 if (attack_mode == ATTACK_MODE_COMBI)
4919 {
4920 fclose (device_param->combs_fp);
4921 }
4922
4923 free (wl_data->buf);
4924 free (wl_data);
4925
4926 fclose (fd);
4927 }
4928
4929 device_param->kernel_accel = 0;
4930 device_param->kernel_loops = 0;
4931
4932 return NULL;
4933 }
4934
4935 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4936 {
4937 if (!device_param)
4938 {
4939 log_error ("ERROR: %s : Invalid argument", __func__);
4940
4941 exit (-1);
4942 }
4943
4944 salt_t *salt_buf = &data.salts_buf[salt_pos];
4945
4946 device_param->kernel_params_buf32[24] = salt_pos;
4947 device_param->kernel_params_buf32[27] = 1;
4948 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4949 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4950 device_param->kernel_params_buf32[30] = 0;
4951 device_param->kernel_params_buf32[31] = 1;
4952
4953 char *dictfile_old = data.dictfile;
4954
4955 const char *weak_hash_check = "weak-hash-check";
4956
4957 data.dictfile = (char *) weak_hash_check;
4958
4959 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4960
4961 data.kernel_rules_buf[0].cmds[0] = 0;
4962
4963 /**
4964 * run the kernel
4965 */
4966
4967 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4968 {
4969 run_kernel (KERN_RUN_1, device_param, 1, false);
4970 }
4971 else
4972 {
4973 run_kernel (KERN_RUN_1, device_param, 1, false);
4974
4975 uint loop_step = 16;
4976
4977 const uint iter = salt_buf->salt_iter;
4978
4979 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4980 {
4981 uint loop_left = iter - loop_pos;
4982
4983 loop_left = MIN (loop_left, loop_step);
4984
4985 device_param->kernel_params_buf32[25] = loop_pos;
4986 device_param->kernel_params_buf32[26] = loop_left;
4987
4988 run_kernel (KERN_RUN_2, device_param, 1, false);
4989 }
4990
4991 run_kernel (KERN_RUN_3, device_param, 1, false);
4992 }
4993
4994 /**
4995 * result
4996 */
4997
4998 check_cracked (device_param, salt_pos);
4999
5000 /**
5001 * cleanup
5002 */
5003
5004 device_param->kernel_params_buf32[24] = 0;
5005 device_param->kernel_params_buf32[25] = 0;
5006 device_param->kernel_params_buf32[26] = 0;
5007 device_param->kernel_params_buf32[27] = 0;
5008 device_param->kernel_params_buf32[28] = 0;
5009 device_param->kernel_params_buf32[29] = 0;
5010 device_param->kernel_params_buf32[30] = 0;
5011 device_param->kernel_params_buf32[31] = 0;
5012
5013 data.dictfile = dictfile_old;
5014
5015 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5016 }
5017
5018 // hlfmt hashcat
5019
5020 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5021 {
5022 if (data.username == 0)
5023 {
5024 *hashbuf_pos = line_buf;
5025 *hashbuf_len = line_len;
5026 }
5027 else
5028 {
5029 char *pos = line_buf;
5030 int len = line_len;
5031
5032 for (int i = 0; i < line_len; i++, pos++, len--)
5033 {
5034 if (line_buf[i] == data.separator)
5035 {
5036 pos++;
5037
5038 len--;
5039
5040 break;
5041 }
5042 }
5043
5044 *hashbuf_pos = pos;
5045 *hashbuf_len = len;
5046 }
5047 }
5048
5049 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5050 {
5051 char *pos = NULL;
5052 int len = 0;
5053
5054 int sep_cnt = 0;
5055
5056 for (int i = 0; i < line_len; i++)
5057 {
5058 if (line_buf[i] == data.separator)
5059 {
5060 sep_cnt++;
5061
5062 continue;
5063 }
5064
5065 if (sep_cnt == 0)
5066 {
5067 if (pos == NULL) pos = line_buf + i;
5068
5069 len++;
5070 }
5071 }
5072
5073 *userbuf_pos = pos;
5074 *userbuf_len = len;
5075 }
5076
5077 // hlfmt pwdump
5078
5079 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5080 {
5081 int sep_cnt = 0;
5082
5083 int sep2_len = 0;
5084 int sep3_len = 0;
5085
5086 for (int i = 0; i < line_len; i++)
5087 {
5088 if (line_buf[i] == ':')
5089 {
5090 sep_cnt++;
5091
5092 continue;
5093 }
5094
5095 if (sep_cnt == 2) sep2_len++;
5096 if (sep_cnt == 3) sep3_len++;
5097 }
5098
5099 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5100
5101 return 0;
5102 }
5103
5104 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5105 {
5106 char *pos = NULL;
5107 int len = 0;
5108
5109 int sep_cnt = 0;
5110
5111 for (int i = 0; i < line_len; i++)
5112 {
5113 if (line_buf[i] == ':')
5114 {
5115 sep_cnt++;
5116
5117 continue;
5118 }
5119
5120 if (data.hash_mode == 1000)
5121 {
5122 if (sep_cnt == 3)
5123 {
5124 if (pos == NULL) pos = line_buf + i;
5125
5126 len++;
5127 }
5128 }
5129 else if (data.hash_mode == 3000)
5130 {
5131 if (sep_cnt == 2)
5132 {
5133 if (pos == NULL) pos = line_buf + i;
5134
5135 len++;
5136 }
5137 }
5138 }
5139
5140 *hashbuf_pos = pos;
5141 *hashbuf_len = len;
5142 }
5143
5144 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5145 {
5146 char *pos = NULL;
5147 int len = 0;
5148
5149 int sep_cnt = 0;
5150
5151 for (int i = 0; i < line_len; i++)
5152 {
5153 if (line_buf[i] == ':')
5154 {
5155 sep_cnt++;
5156
5157 continue;
5158 }
5159
5160 if (sep_cnt == 0)
5161 {
5162 if (pos == NULL) pos = line_buf + i;
5163
5164 len++;
5165 }
5166 }
5167
5168 *userbuf_pos = pos;
5169 *userbuf_len = len;
5170 }
5171
5172 // hlfmt passwd
5173
5174 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5175 {
5176 int sep_cnt = 0;
5177
5178 char sep5_first = 0;
5179 char sep6_first = 0;
5180
5181 for (int i = 0; i < line_len; i++)
5182 {
5183 if (line_buf[i] == ':')
5184 {
5185 sep_cnt++;
5186
5187 continue;
5188 }
5189
5190 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5191 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5192 }
5193
5194 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5195
5196 return 0;
5197 }
5198
5199 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5200 {
5201 char *pos = NULL;
5202 int len = 0;
5203
5204 int sep_cnt = 0;
5205
5206 for (int i = 0; i < line_len; i++)
5207 {
5208 if (line_buf[i] == ':')
5209 {
5210 sep_cnt++;
5211
5212 continue;
5213 }
5214
5215 if (sep_cnt == 1)
5216 {
5217 if (pos == NULL) pos = line_buf + i;
5218
5219 len++;
5220 }
5221 }
5222
5223 *hashbuf_pos = pos;
5224 *hashbuf_len = len;
5225 }
5226
5227 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5228 {
5229 char *pos = NULL;
5230 int len = 0;
5231
5232 int sep_cnt = 0;
5233
5234 for (int i = 0; i < line_len; i++)
5235 {
5236 if (line_buf[i] == ':')
5237 {
5238 sep_cnt++;
5239
5240 continue;
5241 }
5242
5243 if (sep_cnt == 0)
5244 {
5245 if (pos == NULL) pos = line_buf + i;
5246
5247 len++;
5248 }
5249 }
5250
5251 *userbuf_pos = pos;
5252 *userbuf_len = len;
5253 }
5254
5255 // hlfmt shadow
5256
5257 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5258 {
5259 int sep_cnt = 0;
5260
5261 for (int i = 0; i < line_len; i++)
5262 {
5263 if (line_buf[i] == ':') sep_cnt++;
5264 }
5265
5266 if (sep_cnt == 8) return 1;
5267
5268 return 0;
5269 }
5270
5271 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5272 {
5273 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5274 }
5275
5276 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5277 {
5278 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5279 }
5280
5281 // hlfmt main
5282
5283 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5284 {
5285 switch (hashfile_format)
5286 {
5287 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5288 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5289 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5290 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5291 }
5292 }
5293
5294 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5295 {
5296 switch (hashfile_format)
5297 {
5298 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5299 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5300 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5301 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5302 }
5303 }
5304
5305 char *strhlfmt (const uint hashfile_format)
5306 {
5307 switch (hashfile_format)
5308 {
5309 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5310 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5311 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5312 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5313 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5314 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5315 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5316 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5317 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5318 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5319 }
5320
5321 return ((char *) "Unknown");
5322 }
5323
5324 static uint hlfmt_detect (FILE *fp, uint max_check)
5325 {
5326 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5327
5328 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5329 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5330
5331 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5332
5333 uint num_check = 0;
5334
5335 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5336
5337 while (!feof (fp))
5338 {
5339 int line_len = fgetl (fp, line_buf);
5340
5341 if (line_len == 0) continue;
5342
5343 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5344 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5345 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5346
5347 if (num_check == max_check) break;
5348
5349 num_check++;
5350 }
5351
5352 myfree (line_buf);
5353
5354 uint hashlist_format = HLFMT_HASHCAT;
5355
5356 for (int i = 1; i < HLFMTS_CNT; i++)
5357 {
5358 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5359
5360 hashlist_format = i;
5361 }
5362
5363 free (formats_cnt);
5364
5365 return hashlist_format;
5366 }
5367
5368 /**
5369 * some further helper function
5370 */
5371
5372 // wrapper around mymalloc for ADL
5373
5374 #if defined(HAVE_HWMON)
5375 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5376 {
5377 return mymalloc (iSize);
5378 }
5379 #endif
5380
5381 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)
5382 {
5383 u64 collisions = 0;
5384
5385 const uint dgst_pos0 = data.dgst_pos0;
5386 const uint dgst_pos1 = data.dgst_pos1;
5387 const uint dgst_pos2 = data.dgst_pos2;
5388 const uint dgst_pos3 = data.dgst_pos3;
5389
5390 memset (bitmap_a, 0, bitmap_size);
5391 memset (bitmap_b, 0, bitmap_size);
5392 memset (bitmap_c, 0, bitmap_size);
5393 memset (bitmap_d, 0, bitmap_size);
5394
5395 for (uint i = 0; i < digests_cnt; i++)
5396 {
5397 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5398
5399 uint *digest_ptr = (uint *) digests_buf_ptr;
5400
5401 digests_buf_ptr += dgst_size;
5402
5403 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5404 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5405 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5406 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5407
5408 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5409 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5410 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5411 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5412
5413 if (bitmap_a[idx0] & val0) collisions++;
5414 if (bitmap_b[idx1] & val1) collisions++;
5415 if (bitmap_c[idx2] & val2) collisions++;
5416 if (bitmap_d[idx3] & val3) collisions++;
5417
5418 bitmap_a[idx0] |= val0;
5419 bitmap_b[idx1] |= val1;
5420 bitmap_c[idx2] |= val2;
5421 bitmap_d[idx3] |= val3;
5422
5423 if (collisions >= collisions_max) return 0x7fffffff;
5424 }
5425
5426 return collisions;
5427 }
5428
5429 /**
5430 * main
5431 */
5432
5433 #ifdef _WIN
5434 void SetConsoleWindowSize (const int x)
5435 {
5436 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5437
5438 if (h == INVALID_HANDLE_VALUE) return;
5439
5440 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5441
5442 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5443
5444 SMALL_RECT *sr = &bufferInfo.srWindow;
5445
5446 sr->Right = MAX (sr->Right, x - 1);
5447
5448 COORD co;
5449
5450 co.X = sr->Right + 1;
5451 co.Y = 9999;
5452
5453 if (!SetConsoleScreenBufferSize (h, co)) return;
5454
5455 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5456 }
5457 #endif
5458
5459 int main (int argc, char **argv)
5460 {
5461 #ifdef _WIN
5462 SetConsoleWindowSize (132);
5463 #endif
5464
5465 /**
5466 * To help users a bit
5467 */
5468
5469 char *compute = getenv ("COMPUTE");
5470
5471 if (compute)
5472 {
5473 static char display[100];
5474
5475 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5476
5477 putenv (display);
5478 }
5479 else
5480 {
5481 if (getenv ("DISPLAY") == NULL)
5482 putenv ((char *) "DISPLAY=:0");
5483 }
5484
5485 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5486 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5487
5488 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5489 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5490
5491 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5492 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5493
5494 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5495 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5496
5497 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5498 putenv ((char *) "POCL_KERNEL_CACHE=0");
5499
5500 umask (077);
5501
5502 /**
5503 * Real init
5504 */
5505
5506 memset (&data, 0, sizeof (hc_global_data_t));
5507
5508 time_t proc_start;
5509
5510 time (&proc_start);
5511
5512 data.proc_start = proc_start;
5513
5514 int myargc = argc;
5515 char **myargv = argv;
5516
5517 hc_thread_mutex_init (mux_dispatcher);
5518 hc_thread_mutex_init (mux_counter);
5519 hc_thread_mutex_init (mux_display);
5520 hc_thread_mutex_init (mux_adl);
5521
5522 /**
5523 * commandline parameters
5524 */
5525
5526 uint usage = USAGE;
5527 uint version = VERSION;
5528 uint quiet = QUIET;
5529 uint benchmark = BENCHMARK;
5530 uint show = SHOW;
5531 uint left = LEFT;
5532 uint username = USERNAME;
5533 uint remove = REMOVE;
5534 uint remove_timer = REMOVE_TIMER;
5535 u64 skip = SKIP;
5536 u64 limit = LIMIT;
5537 uint keyspace = KEYSPACE;
5538 uint potfile_disable = POTFILE_DISABLE;
5539 char *potfile_path = NULL;
5540 uint debug_mode = DEBUG_MODE;
5541 char *debug_file = NULL;
5542 char *induction_dir = NULL;
5543 char *outfile_check_dir = NULL;
5544 uint force = FORCE;
5545 uint runtime = RUNTIME;
5546 uint hash_mode = HASH_MODE;
5547 uint attack_mode = ATTACK_MODE;
5548 uint markov_disable = MARKOV_DISABLE;
5549 uint markov_classic = MARKOV_CLASSIC;
5550 uint markov_threshold = MARKOV_THRESHOLD;
5551 char *markov_hcstat = NULL;
5552 char *outfile = NULL;
5553 uint outfile_format = OUTFILE_FORMAT;
5554 uint outfile_autohex = OUTFILE_AUTOHEX;
5555 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5556 uint restore = RESTORE;
5557 uint restore_timer = RESTORE_TIMER;
5558 uint restore_disable = RESTORE_DISABLE;
5559 uint status = STATUS;
5560 uint status_timer = STATUS_TIMER;
5561 uint machine_readable = MACHINE_READABLE;
5562 uint loopback = LOOPBACK;
5563 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5564 char *session = NULL;
5565 uint hex_charset = HEX_CHARSET;
5566 uint hex_salt = HEX_SALT;
5567 uint hex_wordlist = HEX_WORDLIST;
5568 uint rp_gen = RP_GEN;
5569 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5570 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5571 uint rp_gen_seed = RP_GEN_SEED;
5572 char *rule_buf_l = (char *) RULE_BUF_L;
5573 char *rule_buf_r = (char *) RULE_BUF_R;
5574 uint increment = INCREMENT;
5575 uint increment_min = INCREMENT_MIN;
5576 uint increment_max = INCREMENT_MAX;
5577 char *cpu_affinity = NULL;
5578 OCL_PTR *ocl = NULL;
5579 char *opencl_devices = NULL;
5580 char *opencl_platforms = NULL;
5581 char *opencl_device_types = NULL;
5582 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5583 char *truecrypt_keyfiles = NULL;
5584 char *veracrypt_keyfiles = NULL;
5585 uint veracrypt_pim = 0;
5586 uint workload_profile = WORKLOAD_PROFILE;
5587 uint kernel_accel = KERNEL_ACCEL;
5588 uint kernel_loops = KERNEL_LOOPS;
5589 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5590 #ifdef HAVE_HWMON
5591 uint gpu_temp_abort = GPU_TEMP_ABORT;
5592 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5593 uint powertune_enable = POWERTUNE_ENABLE;
5594 #endif
5595 uint logfile_disable = LOGFILE_DISABLE;
5596 uint segment_size = SEGMENT_SIZE;
5597 uint scrypt_tmto = SCRYPT_TMTO;
5598 char separator = SEPARATOR;
5599 uint bitmap_min = BITMAP_MIN;
5600 uint bitmap_max = BITMAP_MAX;
5601 char *custom_charset_1 = NULL;
5602 char *custom_charset_2 = NULL;
5603 char *custom_charset_3 = NULL;
5604 char *custom_charset_4 = NULL;
5605
5606 #define IDX_HELP 'h'
5607 #define IDX_VERSION 'V'
5608 #define IDX_VERSION_LOWER 'v'
5609 #define IDX_QUIET 0xff02
5610 #define IDX_SHOW 0xff03
5611 #define IDX_LEFT 0xff04
5612 #define IDX_REMOVE 0xff05
5613 #define IDX_REMOVE_TIMER 0xff37
5614 #define IDX_SKIP 's'
5615 #define IDX_LIMIT 'l'
5616 #define IDX_KEYSPACE 0xff35
5617 #define IDX_POTFILE_DISABLE 0xff06
5618 #define IDX_POTFILE_PATH 0xffe0
5619 #define IDX_DEBUG_MODE 0xff43
5620 #define IDX_DEBUG_FILE 0xff44
5621 #define IDX_INDUCTION_DIR 0xff46
5622 #define IDX_OUTFILE_CHECK_DIR 0xff47
5623 #define IDX_USERNAME 0xff07
5624 #define IDX_FORCE 0xff08
5625 #define IDX_RUNTIME 0xff09
5626 #define IDX_BENCHMARK 'b'
5627 #define IDX_HASH_MODE 'm'
5628 #define IDX_ATTACK_MODE 'a'
5629 #define IDX_RP_FILE 'r'
5630 #define IDX_RP_GEN 'g'
5631 #define IDX_RP_GEN_FUNC_MIN 0xff10
5632 #define IDX_RP_GEN_FUNC_MAX 0xff11
5633 #define IDX_RP_GEN_SEED 0xff34
5634 #define IDX_RULE_BUF_L 'j'
5635 #define IDX_RULE_BUF_R 'k'
5636 #define IDX_INCREMENT 'i'
5637 #define IDX_INCREMENT_MIN 0xff12
5638 #define IDX_INCREMENT_MAX 0xff13
5639 #define IDX_OUTFILE 'o'
5640 #define IDX_OUTFILE_FORMAT 0xff14
5641 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5642 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5643 #define IDX_RESTORE 0xff15
5644 #define IDX_RESTORE_DISABLE 0xff27
5645 #define IDX_STATUS 0xff17
5646 #define IDX_STATUS_TIMER 0xff18
5647 #define IDX_MACHINE_READABLE 0xff50
5648 #define IDX_LOOPBACK 0xff38
5649 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5650 #define IDX_SESSION 0xff19
5651 #define IDX_HEX_CHARSET 0xff20
5652 #define IDX_HEX_SALT 0xff21
5653 #define IDX_HEX_WORDLIST 0xff40
5654 #define IDX_MARKOV_DISABLE 0xff22
5655 #define IDX_MARKOV_CLASSIC 0xff23
5656 #define IDX_MARKOV_THRESHOLD 't'
5657 #define IDX_MARKOV_HCSTAT 0xff24
5658 #define IDX_CPU_AFFINITY 0xff25
5659 #define IDX_OPENCL_DEVICES 'd'
5660 #define IDX_OPENCL_PLATFORMS 0xff72
5661 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5662 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5663 #define IDX_WORKLOAD_PROFILE 'w'
5664 #define IDX_KERNEL_ACCEL 'n'
5665 #define IDX_KERNEL_LOOPS 'u'
5666 #define IDX_GPU_TEMP_DISABLE 0xff29
5667 #define IDX_GPU_TEMP_ABORT 0xff30
5668 #define IDX_GPU_TEMP_RETAIN 0xff31
5669 #define IDX_POWERTUNE_ENABLE 0xff41
5670 #define IDX_LOGFILE_DISABLE 0xff51
5671 #define IDX_TRUECRYPT_KEYFILES 0xff52
5672 #define IDX_VERACRYPT_KEYFILES 0xff53
5673 #define IDX_VERACRYPT_PIM 0xff54
5674 #define IDX_SCRYPT_TMTO 0xff61
5675 #define IDX_SEGMENT_SIZE 'c'
5676 #define IDX_SEPARATOR 'p'
5677 #define IDX_BITMAP_MIN 0xff70
5678 #define IDX_BITMAP_MAX 0xff71
5679 #define IDX_CUSTOM_CHARSET_1 '1'
5680 #define IDX_CUSTOM_CHARSET_2 '2'
5681 #define IDX_CUSTOM_CHARSET_3 '3'
5682 #define IDX_CUSTOM_CHARSET_4 '4'
5683
5684 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5685
5686 struct option long_options[] =
5687 {
5688 {"help", no_argument, 0, IDX_HELP},
5689 {"version", no_argument, 0, IDX_VERSION},
5690 {"quiet", no_argument, 0, IDX_QUIET},
5691 {"show", no_argument, 0, IDX_SHOW},
5692 {"left", no_argument, 0, IDX_LEFT},
5693 {"username", no_argument, 0, IDX_USERNAME},
5694 {"remove", no_argument, 0, IDX_REMOVE},
5695 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5696 {"skip", required_argument, 0, IDX_SKIP},
5697 {"limit", required_argument, 0, IDX_LIMIT},
5698 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5699 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5700 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5701 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5702 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5703 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5704 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5705 {"force", no_argument, 0, IDX_FORCE},
5706 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5707 {"restore", no_argument, 0, IDX_RESTORE},
5708 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5709 {"status", no_argument, 0, IDX_STATUS},
5710 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5711 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5712 {"loopback", no_argument, 0, IDX_LOOPBACK},
5713 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5714 {"session", required_argument, 0, IDX_SESSION},
5715 {"runtime", required_argument, 0, IDX_RUNTIME},
5716 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5717 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5718 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5719 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5720 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5721 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5722 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5723 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5724 {"rules-file", required_argument, 0, IDX_RP_FILE},
5725 {"outfile", required_argument, 0, IDX_OUTFILE},
5726 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5727 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5728 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5729 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5730 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5731 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5732 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5733 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5734 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5735 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5736 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5737 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5738 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5739 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5740 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5741 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5742 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5743 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5744 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5745 #ifdef HAVE_HWMON
5746 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5747 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5748 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5749 #endif // HAVE_HWMON
5750 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5751 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5752 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5753 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5754 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5755 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5756 {"seperator", required_argument, 0, IDX_SEPARATOR},
5757 {"separator", required_argument, 0, IDX_SEPARATOR},
5758 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5759 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5760 {"increment", no_argument, 0, IDX_INCREMENT},
5761 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5762 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5763 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5764 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5765 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5766 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5767 {0, 0, 0, 0}
5768 };
5769
5770 uint rp_files_cnt = 0;
5771
5772 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5773
5774 int option_index = 0;
5775 int c = -1;
5776
5777 optind = 1;
5778 optopt = 0;
5779
5780 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5781 {
5782 switch (c)
5783 {
5784 case IDX_HELP: usage = 1; break;
5785 case IDX_VERSION:
5786 case IDX_VERSION_LOWER: version = 1; break;
5787 case IDX_RESTORE: restore = 1; break;
5788 case IDX_SESSION: session = optarg; break;
5789 case IDX_SHOW: show = 1; break;
5790 case IDX_LEFT: left = 1; break;
5791 case '?': return (-1);
5792 }
5793 }
5794
5795 if (optopt != 0)
5796 {
5797 log_error ("ERROR: Invalid argument specified");
5798
5799 return (-1);
5800 }
5801
5802 /**
5803 * exit functions
5804 */
5805
5806 if (version)
5807 {
5808 log_info ("%s", VERSION_TAG);
5809
5810 return (0);
5811 }
5812
5813 if (usage)
5814 {
5815 usage_big_print (PROGNAME);
5816
5817 return (0);
5818 }
5819
5820 /**
5821 * session needs to be set, always!
5822 */
5823
5824 if (session == NULL) session = (char *) PROGNAME;
5825
5826 /**
5827 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5828 */
5829
5830 char *exec_path = get_exec_path ();
5831
5832 #ifdef LINUX
5833
5834 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5835 char *resolved_exec_path = realpath (exec_path, NULL);
5836
5837 char *install_dir = get_install_dir (resolved_exec_path);
5838 char *profile_dir = NULL;
5839 char *session_dir = NULL;
5840 char *shared_dir = NULL;
5841
5842 if (strcmp (install_dir, resolved_install_folder) == 0)
5843 {
5844 struct passwd *pw = getpwuid (getuid ());
5845
5846 const char *homedir = pw->pw_dir;
5847
5848 profile_dir = get_profile_dir (homedir);
5849 session_dir = get_session_dir (profile_dir);
5850 shared_dir = strdup (SHARED_FOLDER);
5851
5852 mkdir (profile_dir, 0700);
5853 mkdir (session_dir, 0700);
5854 }
5855 else
5856 {
5857 profile_dir = install_dir;
5858 session_dir = install_dir;
5859 shared_dir = install_dir;
5860 }
5861
5862 myfree (resolved_install_folder);
5863 myfree (resolved_exec_path);
5864
5865 #else
5866
5867 char *install_dir = get_install_dir (exec_path);
5868 char *profile_dir = install_dir;
5869 char *session_dir = install_dir;
5870 char *shared_dir = install_dir;
5871
5872 #endif
5873
5874 data.install_dir = install_dir;
5875 data.profile_dir = profile_dir;
5876 data.session_dir = session_dir;
5877 data.shared_dir = shared_dir;
5878
5879 myfree (exec_path);
5880
5881 /**
5882 * kernel cache, we need to make sure folder exist
5883 */
5884
5885 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5886
5887 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5888
5889 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5890
5891 mkdir (kernels_folder, 0700);
5892
5893 myfree (kernels_folder);
5894
5895 /**
5896 * session
5897 */
5898
5899 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5900
5901 data.session = session;
5902
5903 char *eff_restore_file = (char *) mymalloc (session_size);
5904 char *new_restore_file = (char *) mymalloc (session_size);
5905
5906 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5907 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5908
5909 data.eff_restore_file = eff_restore_file;
5910 data.new_restore_file = new_restore_file;
5911
5912 if (((show == 1) || (left == 1)) && (restore == 1))
5913 {
5914 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5915 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5916
5917 return (-1);
5918 }
5919
5920 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5921 if ((show == 1) || (left == 1))
5922 {
5923 restore_disable = 1;
5924
5925 restore = 0;
5926 }
5927
5928 data.restore_disable = restore_disable;
5929
5930 restore_data_t *rd = init_restore (argc, argv);
5931
5932 data.rd = rd;
5933
5934 /**
5935 * restore file
5936 */
5937
5938 if (restore == 1)
5939 {
5940 read_restore (eff_restore_file, rd);
5941
5942 if (rd->version_bin < RESTORE_MIN)
5943 {
5944 log_error ("ERROR: Incompatible restore-file version");
5945
5946 return (-1);
5947 }
5948
5949 myargc = rd->argc;
5950 myargv = rd->argv;
5951
5952 #ifdef _POSIX
5953 rd->pid = getpid ();
5954 #elif _WIN
5955 rd->pid = GetCurrentProcessId ();
5956 #endif
5957 }
5958
5959 uint hash_mode_chgd = 0;
5960 uint runtime_chgd = 0;
5961 uint kernel_loops_chgd = 0;
5962 uint kernel_accel_chgd = 0;
5963 uint attack_mode_chgd = 0;
5964 uint outfile_format_chgd = 0;
5965 uint rp_gen_seed_chgd = 0;
5966 uint remove_timer_chgd = 0;
5967 uint increment_min_chgd = 0;
5968 uint increment_max_chgd = 0;
5969 uint workload_profile_chgd = 0;
5970 uint opencl_vector_width_chgd = 0;
5971
5972 optind = 1;
5973 optopt = 0;
5974 option_index = 0;
5975
5976 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5977 {
5978 switch (c)
5979 {
5980 //case IDX_HELP: usage = 1; break;
5981 //case IDX_VERSION: version = 1; break;
5982 //case IDX_RESTORE: restore = 1; break;
5983 case IDX_QUIET: quiet = 1; break;
5984 //case IDX_SHOW: show = 1; break;
5985 case IDX_SHOW: break;
5986 //case IDX_LEFT: left = 1; break;
5987 case IDX_LEFT: break;
5988 case IDX_USERNAME: username = 1; break;
5989 case IDX_REMOVE: remove = 1; break;
5990 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5991 remove_timer_chgd = 1; break;
5992 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5993 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5994 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5995 case IDX_DEBUG_FILE: debug_file = optarg; break;
5996 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5997 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5998 case IDX_FORCE: force = 1; break;
5999 case IDX_SKIP: skip = atoll (optarg); break;
6000 case IDX_LIMIT: limit = atoll (optarg); break;
6001 case IDX_KEYSPACE: keyspace = 1; break;
6002 case IDX_BENCHMARK: benchmark = 1; break;
6003 case IDX_RESTORE: break;
6004 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6005 case IDX_STATUS: status = 1; break;
6006 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6007 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6008 case IDX_LOOPBACK: loopback = 1; break;
6009 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6010 //case IDX_SESSION: session = optarg; break;
6011 case IDX_SESSION: break;
6012 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6013 hash_mode_chgd = 1; break;
6014 case IDX_RUNTIME: runtime = atoi (optarg);
6015 runtime_chgd = 1; break;
6016 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6017 attack_mode_chgd = 1; break;
6018 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6019 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6020 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6021 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6022 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6023 rp_gen_seed_chgd = 1; break;
6024 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6025 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6026 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6027 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6028 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6029 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6030 case IDX_OUTFILE: outfile = optarg; break;
6031 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6032 outfile_format_chgd = 1; break;
6033 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6034 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6035 case IDX_HEX_CHARSET: hex_charset = 1; break;
6036 case IDX_HEX_SALT: hex_salt = 1; break;
6037 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6038 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6039 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6040 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6041 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6042 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6043 opencl_vector_width_chgd = 1; break;
6044 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6045 workload_profile_chgd = 1; break;
6046 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6047 kernel_accel_chgd = 1; break;
6048 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6049 kernel_loops_chgd = 1; break;
6050 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6051 #ifdef HAVE_HWMON
6052 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6053 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6054 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6055 #endif // HAVE_HWMON
6056 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6057 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6058 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6059 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6060 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6061 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6062 case IDX_SEPARATOR: separator = optarg[0]; break;
6063 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6064 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6065 case IDX_INCREMENT: increment = 1; break;
6066 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6067 increment_min_chgd = 1; break;
6068 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6069 increment_max_chgd = 1; break;
6070 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6071 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6072 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6073 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6074
6075 default:
6076 log_error ("ERROR: Invalid argument specified");
6077 return (-1);
6078 }
6079 }
6080
6081 if (optopt != 0)
6082 {
6083 log_error ("ERROR: Invalid argument specified");
6084
6085 return (-1);
6086 }
6087
6088 /**
6089 * Inform user things getting started,
6090 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6091 * - we do not need to check algorithm_pos
6092 */
6093
6094 if (quiet == 0)
6095 {
6096 if (benchmark == 1)
6097 {
6098 if (machine_readable == 0)
6099 {
6100 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6101 log_info ("");
6102 }
6103 else
6104 {
6105 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6106 }
6107 }
6108 else if (restore == 1)
6109 {
6110 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6111 log_info ("");
6112 }
6113 else
6114 {
6115 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6116 log_info ("");
6117 }
6118 }
6119
6120 /**
6121 * sanity check
6122 */
6123
6124 if (attack_mode > 7)
6125 {
6126 log_error ("ERROR: Invalid attack-mode specified");
6127
6128 return (-1);
6129 }
6130
6131 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6132 {
6133 log_error ("ERROR: Invalid runtime specified");
6134
6135 return (-1);
6136 }
6137
6138 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6139 {
6140 log_error ("ERROR: Invalid hash-type specified");
6141
6142 return (-1);
6143 }
6144
6145 // renamed hash modes
6146
6147 if (hash_mode_chgd)
6148 {
6149 int n = -1;
6150
6151 switch (hash_mode)
6152 {
6153 case 123: n = 124;
6154 break;
6155 }
6156
6157 if (n >= 0)
6158 {
6159 log_error ("Old -m specified, use -m %d instead", n);
6160
6161 return (-1);
6162 }
6163 }
6164
6165 if (username == 1)
6166 {
6167 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6168 {
6169 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6170
6171 return (-1);
6172 }
6173 }
6174
6175 if (outfile_format > 16)
6176 {
6177 log_error ("ERROR: Invalid outfile-format specified");
6178
6179 return (-1);
6180 }
6181
6182 if (left == 1)
6183 {
6184 if (outfile_format_chgd == 1)
6185 {
6186 if (outfile_format > 1)
6187 {
6188 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6189
6190 return (-1);
6191 }
6192 }
6193 else
6194 {
6195 outfile_format = OUTFILE_FMT_HASH;
6196 }
6197 }
6198
6199 if (show == 1)
6200 {
6201 if (outfile_format_chgd == 1)
6202 {
6203 if ((outfile_format > 7) && (outfile_format < 16))
6204 {
6205 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6206
6207 return (-1);
6208 }
6209 }
6210 }
6211
6212 if (increment_min < INCREMENT_MIN)
6213 {
6214 log_error ("ERROR: Invalid increment-min specified");
6215
6216 return (-1);
6217 }
6218
6219 if (increment_max > INCREMENT_MAX)
6220 {
6221 log_error ("ERROR: Invalid increment-max specified");
6222
6223 return (-1);
6224 }
6225
6226 if (increment_min > increment_max)
6227 {
6228 log_error ("ERROR: Invalid increment-min specified");
6229
6230 return (-1);
6231 }
6232
6233 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6234 {
6235 log_error ("ERROR: increment is not allowed in attack-mode 0");
6236
6237 return (-1);
6238 }
6239
6240 if ((increment == 0) && (increment_min_chgd == 1))
6241 {
6242 log_error ("ERROR: increment-min is only supported together with increment switch");
6243
6244 return (-1);
6245 }
6246
6247 if ((increment == 0) && (increment_max_chgd == 1))
6248 {
6249 log_error ("ERROR: increment-max is only supported together with increment switch");
6250
6251 return (-1);
6252 }
6253
6254 if (rp_files_cnt && rp_gen)
6255 {
6256 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6257
6258 return (-1);
6259 }
6260
6261 if (rp_files_cnt || rp_gen)
6262 {
6263 if (attack_mode != ATTACK_MODE_STRAIGHT)
6264 {
6265 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6266
6267 return (-1);
6268 }
6269 }
6270
6271 if (rp_gen_func_min > rp_gen_func_max)
6272 {
6273 log_error ("ERROR: Invalid rp-gen-func-min specified");
6274
6275 return (-1);
6276 }
6277
6278 if (kernel_accel_chgd == 1)
6279 {
6280 if (force == 0)
6281 {
6282 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6283 log_info ("Please consider using the option -w instead");
6284 log_info ("You can use --force to override this but do not post error reports if you do so");
6285 log_info ("");
6286
6287 return (-1);
6288 }
6289
6290 if (kernel_accel < 1)
6291 {
6292 log_error ("ERROR: Invalid kernel-accel specified");
6293
6294 return (-1);
6295 }
6296
6297 if (kernel_accel > 1024)
6298 {
6299 log_error ("ERROR: Invalid kernel-accel specified");
6300
6301 return (-1);
6302 }
6303 }
6304
6305 if (kernel_loops_chgd == 1)
6306 {
6307 if (force == 0)
6308 {
6309 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6310 log_info ("Please consider using the option -w instead");
6311 log_info ("You can use --force to override this but do not post error reports if you do so");
6312 log_info ("");
6313
6314 return (-1);
6315 }
6316
6317 if (kernel_loops < 1)
6318 {
6319 log_error ("ERROR: Invalid kernel-loops specified");
6320
6321 return (-1);
6322 }
6323
6324 if (kernel_loops > 1024)
6325 {
6326 log_error ("ERROR: Invalid kernel-loops specified");
6327
6328 return (-1);
6329 }
6330 }
6331
6332 if ((workload_profile < 1) || (workload_profile > 4))
6333 {
6334 log_error ("ERROR: workload-profile %i not available", workload_profile);
6335
6336 return (-1);
6337 }
6338
6339 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6340 {
6341 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6342
6343 return (-1);
6344 }
6345
6346 if (show == 1 || left == 1)
6347 {
6348 attack_mode = ATTACK_MODE_NONE;
6349
6350 if (remove == 1)
6351 {
6352 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6353
6354 return (-1);
6355 }
6356
6357 if (potfile_disable == 1)
6358 {
6359 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6360
6361 return (-1);
6362 }
6363 }
6364
6365 uint attack_kern = ATTACK_KERN_NONE;
6366
6367 switch (attack_mode)
6368 {
6369 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6370 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6371 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6372 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6373 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6374 }
6375
6376 if (benchmark == 0)
6377 {
6378 if (keyspace == 1)
6379 {
6380 int num_additional_params = 1;
6381
6382 if (attack_kern == ATTACK_KERN_COMBI)
6383 {
6384 num_additional_params = 2;
6385 }
6386
6387 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6388
6389 if (keyspace_wordlist_specified == 0) optind--;
6390 }
6391
6392 if (attack_kern == ATTACK_KERN_NONE)
6393 {
6394 if ((optind + 1) != myargc)
6395 {
6396 usage_mini_print (myargv[0]);
6397
6398 return (-1);
6399 }
6400 }
6401 else if (attack_kern == ATTACK_KERN_STRAIGHT)
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_COMBI)
6411 {
6412 if ((optind + 3) != myargc)
6413 {
6414 usage_mini_print (myargv[0]);
6415
6416 return (-1);
6417 }
6418 }
6419 else if (attack_kern == ATTACK_KERN_BF)
6420 {
6421 if ((optind + 1) > myargc)
6422 {
6423 usage_mini_print (myargv[0]);
6424
6425 return (-1);
6426 }
6427 }
6428 else
6429 {
6430 usage_mini_print (myargv[0]);
6431
6432 return (-1);
6433 }
6434 }
6435 else
6436 {
6437 if (myargv[optind] != 0)
6438 {
6439 log_error ("ERROR: Invalid argument for benchmark mode specified");
6440
6441 return (-1);
6442 }
6443
6444 if (attack_mode_chgd == 1)
6445 {
6446 if (attack_mode != ATTACK_MODE_BF)
6447 {
6448 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6449
6450 return (-1);
6451 }
6452 }
6453 }
6454
6455 if (skip != 0 && limit != 0)
6456 {
6457 limit += skip;
6458 }
6459
6460 if (keyspace == 1)
6461 {
6462 if (show == 1)
6463 {
6464 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6465
6466 return (-1);
6467 }
6468 else if (left == 1)
6469 {
6470 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6471
6472 return (-1);
6473 }
6474
6475 potfile_disable = 1;
6476
6477 restore_disable = 1;
6478
6479 restore = 0;
6480
6481 weak_hash_threshold = 0;
6482
6483 quiet = 1;
6484 }
6485
6486 if (remove_timer_chgd == 1)
6487 {
6488 if (remove == 0)
6489 {
6490 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6491
6492 return (-1);
6493 }
6494
6495 if (remove_timer < 1)
6496 {
6497 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6498
6499 return (-1);
6500 }
6501 }
6502
6503 if (loopback == 1)
6504 {
6505 if (attack_mode == ATTACK_MODE_STRAIGHT)
6506 {
6507 if ((rp_files_cnt == 0) && (rp_gen == 0))
6508 {
6509 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6510
6511 return (-1);
6512 }
6513 }
6514 else
6515 {
6516 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6517
6518 return (-1);
6519 }
6520 }
6521
6522 if (debug_mode > 0)
6523 {
6524 if (attack_mode != ATTACK_MODE_STRAIGHT)
6525 {
6526 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6527
6528 return (-1);
6529 }
6530
6531 if ((rp_files_cnt == 0) && (rp_gen == 0))
6532 {
6533 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6534
6535 return (-1);
6536 }
6537 }
6538
6539 if (debug_mode > 4)
6540 {
6541 log_error ("ERROR: Invalid debug-mode specified");
6542
6543 return (-1);
6544 }
6545
6546 if (debug_file != NULL)
6547 {
6548 if (debug_mode < 1)
6549 {
6550 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6551
6552 return (-1);
6553 }
6554 }
6555
6556 if (induction_dir != NULL)
6557 {
6558 if (attack_mode == ATTACK_MODE_BF)
6559 {
6560 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6561
6562 return (-1);
6563 }
6564 }
6565
6566 if (attack_mode != ATTACK_MODE_STRAIGHT)
6567 {
6568 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6569 {
6570 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6571
6572 return (-1);
6573 }
6574
6575 weak_hash_threshold = 0;
6576 }
6577
6578 /**
6579 * induction directory
6580 */
6581
6582 char *induction_directory = NULL;
6583
6584 if (attack_mode != ATTACK_MODE_BF)
6585 {
6586 if (induction_dir == NULL)
6587 {
6588 induction_directory = (char *) mymalloc (session_size);
6589
6590 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6591
6592 // create induction folder if it does not already exist
6593
6594 if (keyspace == 0)
6595 {
6596 if (rmdir (induction_directory) == -1)
6597 {
6598 if (errno == ENOENT)
6599 {
6600 // good, we can ignore
6601 }
6602 else if (errno == ENOTEMPTY)
6603 {
6604 char *induction_directory_mv = (char *) mymalloc (session_size);
6605
6606 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6607
6608 if (rename (induction_directory, induction_directory_mv) != 0)
6609 {
6610 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6611
6612 return (-1);
6613 }
6614 }
6615 else
6616 {
6617 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6618
6619 return (-1);
6620 }
6621 }
6622
6623 if (mkdir (induction_directory, 0700) == -1)
6624 {
6625 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6626
6627 return (-1);
6628 }
6629 }
6630 }
6631 else
6632 {
6633 induction_directory = induction_dir;
6634 }
6635 }
6636
6637 data.induction_directory = induction_directory;
6638
6639 /**
6640 * loopback
6641 */
6642
6643 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6644
6645 char *loopback_file = (char *) mymalloc (loopback_size);
6646
6647 /**
6648 * tuning db
6649 */
6650
6651 char tuning_db_file[256] = { 0 };
6652
6653 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6654
6655 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6656
6657 /**
6658 * outfile-check directory
6659 */
6660
6661 char *outfile_check_directory = NULL;
6662
6663 if (outfile_check_dir == NULL)
6664 {
6665 outfile_check_directory = (char *) mymalloc (session_size);
6666
6667 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6668 }
6669 else
6670 {
6671 outfile_check_directory = outfile_check_dir;
6672 }
6673
6674 data.outfile_check_directory = outfile_check_directory;
6675
6676 if (keyspace == 0)
6677 {
6678 struct stat outfile_check_stat;
6679
6680 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6681 {
6682 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6683
6684 if (is_dir == 0)
6685 {
6686 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6687
6688 return (-1);
6689 }
6690 }
6691 else if (outfile_check_dir == NULL)
6692 {
6693 if (mkdir (outfile_check_directory, 0700) == -1)
6694 {
6695 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6696
6697 return (-1);
6698 }
6699 }
6700 }
6701
6702 /**
6703 * special other stuff
6704 */
6705
6706 if (hash_mode == 9710)
6707 {
6708 outfile_format = 5;
6709 outfile_format_chgd = 1;
6710 }
6711
6712 if (hash_mode == 9810)
6713 {
6714 outfile_format = 5;
6715 outfile_format_chgd = 1;
6716 }
6717
6718 if (hash_mode == 10410)
6719 {
6720 outfile_format = 5;
6721 outfile_format_chgd = 1;
6722 }
6723
6724 /**
6725 * store stuff
6726 */
6727
6728 data.hash_mode = hash_mode;
6729 data.restore = restore;
6730 data.restore_timer = restore_timer;
6731 data.restore_disable = restore_disable;
6732 data.status = status;
6733 data.status_timer = status_timer;
6734 data.machine_readable = machine_readable;
6735 data.loopback = loopback;
6736 data.runtime = runtime;
6737 data.remove = remove;
6738 data.remove_timer = remove_timer;
6739 data.debug_mode = debug_mode;
6740 data.debug_file = debug_file;
6741 data.username = username;
6742 data.quiet = quiet;
6743 data.outfile = outfile;
6744 data.outfile_format = outfile_format;
6745 data.outfile_autohex = outfile_autohex;
6746 data.hex_charset = hex_charset;
6747 data.hex_salt = hex_salt;
6748 data.hex_wordlist = hex_wordlist;
6749 data.separator = separator;
6750 data.rp_files = rp_files;
6751 data.rp_files_cnt = rp_files_cnt;
6752 data.rp_gen = rp_gen;
6753 data.rp_gen_seed = rp_gen_seed;
6754 data.force = force;
6755 data.benchmark = benchmark;
6756 data.skip = skip;
6757 data.limit = limit;
6758 #ifdef HAVE_HWMON
6759 data.powertune_enable = powertune_enable;
6760 #endif
6761 data.logfile_disable = logfile_disable;
6762 data.truecrypt_keyfiles = truecrypt_keyfiles;
6763 data.veracrypt_keyfiles = veracrypt_keyfiles;
6764 data.veracrypt_pim = veracrypt_pim;
6765 data.scrypt_tmto = scrypt_tmto;
6766 data.workload_profile = workload_profile;
6767
6768 /**
6769 * cpu affinity
6770 */
6771
6772 if (cpu_affinity)
6773 {
6774 set_cpu_affinity (cpu_affinity);
6775 }
6776
6777 if (rp_gen_seed_chgd == 0)
6778 {
6779 srand (proc_start);
6780 }
6781 else
6782 {
6783 srand (rp_gen_seed);
6784 }
6785
6786 /**
6787 * logfile init
6788 */
6789
6790 if (logfile_disable == 0)
6791 {
6792 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6793
6794 char *logfile = (char *) mymalloc (logfile_size);
6795
6796 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6797
6798 data.logfile = logfile;
6799
6800 char *topid = logfile_generate_topid ();
6801
6802 data.topid = topid;
6803 }
6804
6805 // logfile_append() checks for logfile_disable internally to make it easier from here
6806
6807 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6808 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6809 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6810 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6811 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6812 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6813 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6814 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6815 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6816 #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));
6817
6818 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6819 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6820 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6821 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6822 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6823 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6824 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6825 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6826
6827 logfile_top_msg ("START");
6828
6829 logfile_top_uint (attack_mode);
6830 logfile_top_uint (attack_kern);
6831 logfile_top_uint (benchmark);
6832 logfile_top_uint (bitmap_min);
6833 logfile_top_uint (bitmap_max);
6834 logfile_top_uint (debug_mode);
6835 logfile_top_uint (force);
6836 logfile_top_uint (kernel_accel);
6837 logfile_top_uint (kernel_loops);
6838 logfile_top_uint (gpu_temp_disable);
6839 #ifdef HAVE_HWMON
6840 logfile_top_uint (gpu_temp_abort);
6841 logfile_top_uint (gpu_temp_retain);
6842 #endif
6843 logfile_top_uint (hash_mode);
6844 logfile_top_uint (hex_charset);
6845 logfile_top_uint (hex_salt);
6846 logfile_top_uint (hex_wordlist);
6847 logfile_top_uint (increment);
6848 logfile_top_uint (increment_max);
6849 logfile_top_uint (increment_min);
6850 logfile_top_uint (keyspace);
6851 logfile_top_uint (left);
6852 logfile_top_uint (logfile_disable);
6853 logfile_top_uint (loopback);
6854 logfile_top_uint (markov_classic);
6855 logfile_top_uint (markov_disable);
6856 logfile_top_uint (markov_threshold);
6857 logfile_top_uint (outfile_autohex);
6858 logfile_top_uint (outfile_check_timer);
6859 logfile_top_uint (outfile_format);
6860 logfile_top_uint (potfile_disable);
6861 logfile_top_string (potfile_path);
6862 #if defined(HAVE_HWMON)
6863 logfile_top_uint (powertune_enable);
6864 #endif
6865 logfile_top_uint (scrypt_tmto);
6866 logfile_top_uint (quiet);
6867 logfile_top_uint (remove);
6868 logfile_top_uint (remove_timer);
6869 logfile_top_uint (restore);
6870 logfile_top_uint (restore_disable);
6871 logfile_top_uint (restore_timer);
6872 logfile_top_uint (rp_gen);
6873 logfile_top_uint (rp_gen_func_max);
6874 logfile_top_uint (rp_gen_func_min);
6875 logfile_top_uint (rp_gen_seed);
6876 logfile_top_uint (runtime);
6877 logfile_top_uint (segment_size);
6878 logfile_top_uint (show);
6879 logfile_top_uint (status);
6880 logfile_top_uint (machine_readable);
6881 logfile_top_uint (status_timer);
6882 logfile_top_uint (usage);
6883 logfile_top_uint (username);
6884 logfile_top_uint (version);
6885 logfile_top_uint (weak_hash_threshold);
6886 logfile_top_uint (workload_profile);
6887 logfile_top_uint64 (limit);
6888 logfile_top_uint64 (skip);
6889 logfile_top_char (separator);
6890 logfile_top_string (cpu_affinity);
6891 logfile_top_string (custom_charset_1);
6892 logfile_top_string (custom_charset_2);
6893 logfile_top_string (custom_charset_3);
6894 logfile_top_string (custom_charset_4);
6895 logfile_top_string (debug_file);
6896 logfile_top_string (opencl_devices);
6897 logfile_top_string (opencl_platforms);
6898 logfile_top_string (opencl_device_types);
6899 logfile_top_uint (opencl_vector_width);
6900 logfile_top_string (induction_dir);
6901 logfile_top_string (markov_hcstat);
6902 logfile_top_string (outfile);
6903 logfile_top_string (outfile_check_dir);
6904 logfile_top_string (rule_buf_l);
6905 logfile_top_string (rule_buf_r);
6906 logfile_top_string (session);
6907 logfile_top_string (truecrypt_keyfiles);
6908 logfile_top_string (veracrypt_keyfiles);
6909 logfile_top_uint (veracrypt_pim);
6910
6911 /**
6912 * Init OpenCL library loader
6913 */
6914
6915 if (keyspace == 0)
6916 {
6917 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6918
6919 ocl_init (ocl);
6920
6921 data.ocl = ocl;
6922 }
6923
6924 /**
6925 * OpenCL platform selection
6926 */
6927
6928 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6929
6930 /**
6931 * OpenCL device selection
6932 */
6933
6934 u32 devices_filter = setup_devices_filter (opencl_devices);
6935
6936 /**
6937 * OpenCL device type selection
6938 */
6939
6940 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6941
6942 /**
6943 * benchmark
6944 */
6945
6946 if (benchmark == 1)
6947 {
6948 /**
6949 * disable useless stuff for benchmark
6950 */
6951
6952 status_timer = 0;
6953 restore_timer = 0;
6954 restore_disable = 1;
6955 potfile_disable = 1;
6956 weak_hash_threshold = 0;
6957 gpu_temp_disable = 1;
6958
6959 #ifdef HAVE_HWMON
6960 powertune_enable = 1;
6961 #endif
6962
6963 data.status_timer = status_timer;
6964 data.restore_timer = restore_timer;
6965 data.restore_disable = restore_disable;
6966
6967 /**
6968 * force attack mode to be bruteforce
6969 */
6970
6971 attack_mode = ATTACK_MODE_BF;
6972 attack_kern = ATTACK_KERN_BF;
6973
6974 if (workload_profile_chgd == 0)
6975 {
6976 workload_profile = 3;
6977
6978 data.workload_profile = workload_profile;
6979 }
6980 }
6981
6982 /**
6983 * config
6984 */
6985
6986 uint hash_type = 0;
6987 uint salt_type = 0;
6988 uint attack_exec = 0;
6989 uint opts_type = 0;
6990 uint kern_type = 0;
6991 uint dgst_size = 0;
6992 uint esalt_size = 0;
6993 uint opti_type = 0;
6994 uint dgst_pos0 = -1;
6995 uint dgst_pos1 = -1;
6996 uint dgst_pos2 = -1;
6997 uint dgst_pos3 = -1;
6998
6999 int (*parse_func) (char *, uint, hash_t *);
7000 int (*sort_by_digest) (const void *, const void *);
7001
7002 uint algorithm_pos = 0;
7003 uint algorithm_max = 1;
7004
7005 uint *algorithms = default_benchmark_algorithms;
7006
7007 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7008
7009 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7010 {
7011 /*
7012 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7013 * the following algos are skipped entirely
7014 */
7015
7016 if (algorithm_pos > 0)
7017 {
7018 local_free (rd);
7019
7020 rd = init_restore (argc, argv);
7021
7022 data.rd = rd;
7023 }
7024
7025 /**
7026 * update hash_mode in case of multihash benchmark
7027 */
7028
7029 if (benchmark == 1)
7030 {
7031 if (hash_mode_chgd == 0)
7032 {
7033 hash_mode = algorithms[algorithm_pos];
7034
7035 data.hash_mode = hash_mode;
7036 }
7037
7038 quiet = 1;
7039
7040 data.quiet = quiet;
7041 }
7042
7043 switch (hash_mode)
7044 {
7045 case 0: hash_type = HASH_TYPE_MD5;
7046 salt_type = SALT_TYPE_NONE;
7047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7048 opts_type = OPTS_TYPE_PT_GENERATE_LE
7049 | OPTS_TYPE_PT_ADD80
7050 | OPTS_TYPE_PT_ADDBITS14;
7051 kern_type = KERN_TYPE_MD5;
7052 dgst_size = DGST_SIZE_4_4;
7053 parse_func = md5_parse_hash;
7054 sort_by_digest = sort_by_digest_4_4;
7055 opti_type = OPTI_TYPE_ZERO_BYTE
7056 | OPTI_TYPE_PRECOMPUTE_INIT
7057 | OPTI_TYPE_PRECOMPUTE_MERKLE
7058 | OPTI_TYPE_MEET_IN_MIDDLE
7059 | OPTI_TYPE_EARLY_SKIP
7060 | OPTI_TYPE_NOT_ITERATED
7061 | OPTI_TYPE_NOT_SALTED
7062 | OPTI_TYPE_RAW_HASH;
7063 dgst_pos0 = 0;
7064 dgst_pos1 = 3;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 10: hash_type = HASH_TYPE_MD5;
7070 salt_type = SALT_TYPE_INTERN;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_LE
7073 | OPTS_TYPE_ST_ADD80
7074 | OPTS_TYPE_ST_ADDBITS14;
7075 kern_type = KERN_TYPE_MD5_PWSLT;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = md5s_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_MEET_IN_MIDDLE
7083 | OPTI_TYPE_EARLY_SKIP
7084 | OPTI_TYPE_NOT_ITERATED
7085 | OPTI_TYPE_APPENDED_SALT
7086 | OPTI_TYPE_RAW_HASH;
7087 dgst_pos0 = 0;
7088 dgst_pos1 = 3;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 11: hash_type = HASH_TYPE_MD5;
7094 salt_type = SALT_TYPE_INTERN;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_LE
7097 | OPTS_TYPE_ST_ADD80
7098 | OPTS_TYPE_ST_ADDBITS14;
7099 kern_type = KERN_TYPE_MD5_PWSLT;
7100 dgst_size = DGST_SIZE_4_4;
7101 parse_func = joomla_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_PRECOMPUTE_INIT
7105 | OPTI_TYPE_PRECOMPUTE_MERKLE
7106 | OPTI_TYPE_MEET_IN_MIDDLE
7107 | OPTI_TYPE_EARLY_SKIP
7108 | OPTI_TYPE_NOT_ITERATED
7109 | OPTI_TYPE_APPENDED_SALT
7110 | OPTI_TYPE_RAW_HASH;
7111 dgst_pos0 = 0;
7112 dgst_pos1 = 3;
7113 dgst_pos2 = 2;
7114 dgst_pos3 = 1;
7115 break;
7116
7117 case 12: hash_type = HASH_TYPE_MD5;
7118 salt_type = SALT_TYPE_INTERN;
7119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7120 opts_type = OPTS_TYPE_PT_GENERATE_LE
7121 | OPTS_TYPE_ST_ADD80
7122 | OPTS_TYPE_ST_ADDBITS14;
7123 kern_type = KERN_TYPE_MD5_PWSLT;
7124 dgst_size = DGST_SIZE_4_4;
7125 parse_func = postgresql_parse_hash;
7126 sort_by_digest = sort_by_digest_4_4;
7127 opti_type = OPTI_TYPE_ZERO_BYTE
7128 | OPTI_TYPE_PRECOMPUTE_INIT
7129 | OPTI_TYPE_PRECOMPUTE_MERKLE
7130 | OPTI_TYPE_MEET_IN_MIDDLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_APPENDED_SALT
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 3;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 20: hash_type = HASH_TYPE_MD5;
7142 salt_type = SALT_TYPE_INTERN;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_LE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS14;
7147 kern_type = KERN_TYPE_MD5_SLTPW;
7148 dgst_size = DGST_SIZE_4_4;
7149 parse_func = md5s_parse_hash;
7150 sort_by_digest = sort_by_digest_4_4;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_PREPENDED_SALT
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 0;
7159 dgst_pos1 = 3;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 21: hash_type = HASH_TYPE_MD5;
7165 salt_type = SALT_TYPE_INTERN;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_LE
7168 | OPTS_TYPE_PT_ADD80
7169 | OPTS_TYPE_PT_ADDBITS14;
7170 kern_type = KERN_TYPE_MD5_SLTPW;
7171 dgst_size = DGST_SIZE_4_4;
7172 parse_func = osc_parse_hash;
7173 sort_by_digest = sort_by_digest_4_4;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_PREPENDED_SALT
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 0;
7182 dgst_pos1 = 3;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 22: hash_type = HASH_TYPE_MD5;
7188 salt_type = SALT_TYPE_EMBEDDED;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_LE
7191 | OPTS_TYPE_PT_ADD80
7192 | OPTS_TYPE_PT_ADDBITS14;
7193 kern_type = KERN_TYPE_MD5_SLTPW;
7194 dgst_size = DGST_SIZE_4_4;
7195 parse_func = netscreen_parse_hash;
7196 sort_by_digest = sort_by_digest_4_4;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_PRECOMPUTE_INIT
7199 | OPTI_TYPE_PRECOMPUTE_MERKLE
7200 | OPTI_TYPE_EARLY_SKIP
7201 | OPTI_TYPE_NOT_ITERATED
7202 | OPTI_TYPE_PREPENDED_SALT
7203 | OPTI_TYPE_RAW_HASH;
7204 dgst_pos0 = 0;
7205 dgst_pos1 = 3;
7206 dgst_pos2 = 2;
7207 dgst_pos3 = 1;
7208 break;
7209
7210 case 23: hash_type = HASH_TYPE_MD5;
7211 salt_type = SALT_TYPE_EMBEDDED;
7212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7213 opts_type = OPTS_TYPE_PT_GENERATE_LE
7214 | OPTS_TYPE_PT_ADD80
7215 | OPTS_TYPE_PT_ADDBITS14;
7216 kern_type = KERN_TYPE_MD5_SLTPW;
7217 dgst_size = DGST_SIZE_4_4;
7218 parse_func = skype_parse_hash;
7219 sort_by_digest = sort_by_digest_4_4;
7220 opti_type = OPTI_TYPE_ZERO_BYTE
7221 | OPTI_TYPE_PRECOMPUTE_INIT
7222 | OPTI_TYPE_PRECOMPUTE_MERKLE
7223 | OPTI_TYPE_EARLY_SKIP
7224 | OPTI_TYPE_NOT_ITERATED
7225 | OPTI_TYPE_PREPENDED_SALT
7226 | OPTI_TYPE_RAW_HASH;
7227 dgst_pos0 = 0;
7228 dgst_pos1 = 3;
7229 dgst_pos2 = 2;
7230 dgst_pos3 = 1;
7231 break;
7232
7233 case 30: hash_type = HASH_TYPE_MD5;
7234 salt_type = SALT_TYPE_INTERN;
7235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7236 opts_type = OPTS_TYPE_PT_GENERATE_LE
7237 | OPTS_TYPE_PT_UNICODE
7238 | OPTS_TYPE_ST_ADD80
7239 | OPTS_TYPE_ST_ADDBITS14;
7240 kern_type = KERN_TYPE_MD5_PWUSLT;
7241 dgst_size = DGST_SIZE_4_4;
7242 parse_func = md5s_parse_hash;
7243 sort_by_digest = sort_by_digest_4_4;
7244 opti_type = OPTI_TYPE_ZERO_BYTE
7245 | OPTI_TYPE_PRECOMPUTE_INIT
7246 | OPTI_TYPE_PRECOMPUTE_MERKLE
7247 | OPTI_TYPE_MEET_IN_MIDDLE
7248 | OPTI_TYPE_EARLY_SKIP
7249 | OPTI_TYPE_NOT_ITERATED
7250 | OPTI_TYPE_APPENDED_SALT
7251 | OPTI_TYPE_RAW_HASH;
7252 dgst_pos0 = 0;
7253 dgst_pos1 = 3;
7254 dgst_pos2 = 2;
7255 dgst_pos3 = 1;
7256 break;
7257
7258 case 40: hash_type = HASH_TYPE_MD5;
7259 salt_type = SALT_TYPE_INTERN;
7260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7261 opts_type = OPTS_TYPE_PT_GENERATE_LE
7262 | OPTS_TYPE_PT_ADD80
7263 | OPTS_TYPE_PT_ADDBITS14
7264 | OPTS_TYPE_PT_UNICODE;
7265 kern_type = KERN_TYPE_MD5_SLTPWU;
7266 dgst_size = DGST_SIZE_4_4;
7267 parse_func = md5s_parse_hash;
7268 sort_by_digest = sort_by_digest_4_4;
7269 opti_type = OPTI_TYPE_ZERO_BYTE
7270 | OPTI_TYPE_PRECOMPUTE_INIT
7271 | OPTI_TYPE_PRECOMPUTE_MERKLE
7272 | OPTI_TYPE_EARLY_SKIP
7273 | OPTI_TYPE_NOT_ITERATED
7274 | OPTI_TYPE_PREPENDED_SALT
7275 | OPTI_TYPE_RAW_HASH;
7276 dgst_pos0 = 0;
7277 dgst_pos1 = 3;
7278 dgst_pos2 = 2;
7279 dgst_pos3 = 1;
7280 break;
7281
7282 case 50: hash_type = HASH_TYPE_MD5;
7283 salt_type = SALT_TYPE_INTERN;
7284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7285 opts_type = OPTS_TYPE_PT_GENERATE_LE
7286 | OPTS_TYPE_ST_ADD80
7287 | OPTS_TYPE_ST_ADDBITS14;
7288 kern_type = KERN_TYPE_HMACMD5_PW;
7289 dgst_size = DGST_SIZE_4_4;
7290 parse_func = hmacmd5_parse_hash;
7291 sort_by_digest = sort_by_digest_4_4;
7292 opti_type = OPTI_TYPE_ZERO_BYTE
7293 | OPTI_TYPE_NOT_ITERATED;
7294 dgst_pos0 = 0;
7295 dgst_pos1 = 3;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 60: hash_type = HASH_TYPE_MD5;
7301 salt_type = SALT_TYPE_INTERN;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_LE
7304 | OPTS_TYPE_PT_ADD80
7305 | OPTS_TYPE_PT_ADDBITS14;
7306 kern_type = KERN_TYPE_HMACMD5_SLT;
7307 dgst_size = DGST_SIZE_4_4;
7308 parse_func = hmacmd5_parse_hash;
7309 sort_by_digest = sort_by_digest_4_4;
7310 opti_type = OPTI_TYPE_ZERO_BYTE
7311 | OPTI_TYPE_NOT_ITERATED;
7312 dgst_pos0 = 0;
7313 dgst_pos1 = 3;
7314 dgst_pos2 = 2;
7315 dgst_pos3 = 1;
7316 break;
7317
7318 case 100: hash_type = HASH_TYPE_SHA1;
7319 salt_type = SALT_TYPE_NONE;
7320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7321 opts_type = OPTS_TYPE_PT_GENERATE_BE
7322 | OPTS_TYPE_PT_ADD80
7323 | OPTS_TYPE_PT_ADDBITS15;
7324 kern_type = KERN_TYPE_SHA1;
7325 dgst_size = DGST_SIZE_4_5;
7326 parse_func = sha1_parse_hash;
7327 sort_by_digest = sort_by_digest_4_5;
7328 opti_type = OPTI_TYPE_ZERO_BYTE
7329 | OPTI_TYPE_PRECOMPUTE_INIT
7330 | OPTI_TYPE_PRECOMPUTE_MERKLE
7331 | OPTI_TYPE_EARLY_SKIP
7332 | OPTI_TYPE_NOT_ITERATED
7333 | OPTI_TYPE_NOT_SALTED
7334 | OPTI_TYPE_RAW_HASH;
7335 dgst_pos0 = 3;
7336 dgst_pos1 = 4;
7337 dgst_pos2 = 2;
7338 dgst_pos3 = 1;
7339 break;
7340
7341 case 101: hash_type = HASH_TYPE_SHA1;
7342 salt_type = SALT_TYPE_NONE;
7343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7344 opts_type = OPTS_TYPE_PT_GENERATE_BE
7345 | OPTS_TYPE_PT_ADD80
7346 | OPTS_TYPE_PT_ADDBITS15;
7347 kern_type = KERN_TYPE_SHA1;
7348 dgst_size = DGST_SIZE_4_5;
7349 parse_func = sha1b64_parse_hash;
7350 sort_by_digest = sort_by_digest_4_5;
7351 opti_type = OPTI_TYPE_ZERO_BYTE
7352 | OPTI_TYPE_PRECOMPUTE_INIT
7353 | OPTI_TYPE_PRECOMPUTE_MERKLE
7354 | OPTI_TYPE_EARLY_SKIP
7355 | OPTI_TYPE_NOT_ITERATED
7356 | OPTI_TYPE_NOT_SALTED
7357 | OPTI_TYPE_RAW_HASH;
7358 dgst_pos0 = 3;
7359 dgst_pos1 = 4;
7360 dgst_pos2 = 2;
7361 dgst_pos3 = 1;
7362 break;
7363
7364 case 110: hash_type = HASH_TYPE_SHA1;
7365 salt_type = SALT_TYPE_INTERN;
7366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7367 opts_type = OPTS_TYPE_PT_GENERATE_BE
7368 | OPTS_TYPE_ST_ADD80
7369 | OPTS_TYPE_ST_ADDBITS15;
7370 kern_type = KERN_TYPE_SHA1_PWSLT;
7371 dgst_size = DGST_SIZE_4_5;
7372 parse_func = sha1s_parse_hash;
7373 sort_by_digest = sort_by_digest_4_5;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_APPENDED_SALT
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 4;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 111: hash_type = HASH_TYPE_SHA1;
7388 salt_type = SALT_TYPE_EMBEDDED;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_ST_ADD80
7392 | OPTS_TYPE_ST_ADDBITS15;
7393 kern_type = KERN_TYPE_SHA1_PWSLT;
7394 dgst_size = DGST_SIZE_4_5;
7395 parse_func = sha1b64s_parse_hash;
7396 sort_by_digest = sort_by_digest_4_5;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_PRECOMPUTE_INIT
7399 | OPTI_TYPE_PRECOMPUTE_MERKLE
7400 | OPTI_TYPE_EARLY_SKIP
7401 | OPTI_TYPE_NOT_ITERATED
7402 | OPTI_TYPE_APPENDED_SALT
7403 | OPTI_TYPE_RAW_HASH;
7404 dgst_pos0 = 3;
7405 dgst_pos1 = 4;
7406 dgst_pos2 = 2;
7407 dgst_pos3 = 1;
7408 break;
7409
7410 case 112: hash_type = HASH_TYPE_SHA1;
7411 salt_type = SALT_TYPE_INTERN;
7412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7413 opts_type = OPTS_TYPE_PT_GENERATE_BE
7414 | OPTS_TYPE_ST_ADD80
7415 | OPTS_TYPE_ST_ADDBITS15
7416 | OPTS_TYPE_ST_HEX;
7417 kern_type = KERN_TYPE_SHA1_PWSLT;
7418 dgst_size = DGST_SIZE_4_5;
7419 parse_func = oracles_parse_hash;
7420 sort_by_digest = sort_by_digest_4_5;
7421 opti_type = OPTI_TYPE_ZERO_BYTE
7422 | OPTI_TYPE_PRECOMPUTE_INIT
7423 | OPTI_TYPE_PRECOMPUTE_MERKLE
7424 | OPTI_TYPE_EARLY_SKIP
7425 | OPTI_TYPE_NOT_ITERATED
7426 | OPTI_TYPE_APPENDED_SALT
7427 | OPTI_TYPE_RAW_HASH;
7428 dgst_pos0 = 3;
7429 dgst_pos1 = 4;
7430 dgst_pos2 = 2;
7431 dgst_pos3 = 1;
7432 break;
7433
7434 case 120: hash_type = HASH_TYPE_SHA1;
7435 salt_type = SALT_TYPE_INTERN;
7436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7437 opts_type = OPTS_TYPE_PT_GENERATE_BE
7438 | OPTS_TYPE_PT_ADD80
7439 | OPTS_TYPE_PT_ADDBITS15;
7440 kern_type = KERN_TYPE_SHA1_SLTPW;
7441 dgst_size = DGST_SIZE_4_5;
7442 parse_func = sha1s_parse_hash;
7443 sort_by_digest = sort_by_digest_4_5;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_EARLY_SKIP
7448 | OPTI_TYPE_NOT_ITERATED
7449 | OPTI_TYPE_PREPENDED_SALT
7450 | OPTI_TYPE_RAW_HASH;
7451 dgst_pos0 = 3;
7452 dgst_pos1 = 4;
7453 dgst_pos2 = 2;
7454 dgst_pos3 = 1;
7455 break;
7456
7457 case 121: hash_type = HASH_TYPE_SHA1;
7458 salt_type = SALT_TYPE_INTERN;
7459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7460 opts_type = OPTS_TYPE_PT_GENERATE_BE
7461 | OPTS_TYPE_PT_ADD80
7462 | OPTS_TYPE_PT_ADDBITS15
7463 | OPTS_TYPE_ST_LOWER;
7464 kern_type = KERN_TYPE_SHA1_SLTPW;
7465 dgst_size = DGST_SIZE_4_5;
7466 parse_func = smf_parse_hash;
7467 sort_by_digest = sort_by_digest_4_5;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_EARLY_SKIP
7472 | OPTI_TYPE_NOT_ITERATED
7473 | OPTI_TYPE_PREPENDED_SALT
7474 | OPTI_TYPE_RAW_HASH;
7475 dgst_pos0 = 3;
7476 dgst_pos1 = 4;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 1;
7479 break;
7480
7481 case 122: hash_type = HASH_TYPE_SHA1;
7482 salt_type = SALT_TYPE_EMBEDDED;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_ADD80
7486 | OPTS_TYPE_PT_ADDBITS15
7487 | OPTS_TYPE_ST_HEX;
7488 kern_type = KERN_TYPE_SHA1_SLTPW;
7489 dgst_size = DGST_SIZE_4_5;
7490 parse_func = osx1_parse_hash;
7491 sort_by_digest = sort_by_digest_4_5;
7492 opti_type = OPTI_TYPE_ZERO_BYTE
7493 | OPTI_TYPE_PRECOMPUTE_INIT
7494 | OPTI_TYPE_PRECOMPUTE_MERKLE
7495 | OPTI_TYPE_EARLY_SKIP
7496 | OPTI_TYPE_NOT_ITERATED
7497 | OPTI_TYPE_PREPENDED_SALT
7498 | OPTI_TYPE_RAW_HASH;
7499 dgst_pos0 = 3;
7500 dgst_pos1 = 4;
7501 dgst_pos2 = 2;
7502 dgst_pos3 = 1;
7503 break;
7504
7505 case 124: hash_type = HASH_TYPE_SHA1;
7506 salt_type = SALT_TYPE_EMBEDDED;
7507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7508 opts_type = OPTS_TYPE_PT_GENERATE_BE
7509 | OPTS_TYPE_PT_ADD80
7510 | OPTS_TYPE_PT_ADDBITS15;
7511 kern_type = KERN_TYPE_SHA1_SLTPW;
7512 dgst_size = DGST_SIZE_4_5;
7513 parse_func = djangosha1_parse_hash;
7514 sort_by_digest = sort_by_digest_4_5;
7515 opti_type = OPTI_TYPE_ZERO_BYTE
7516 | OPTI_TYPE_PRECOMPUTE_INIT
7517 | OPTI_TYPE_PRECOMPUTE_MERKLE
7518 | OPTI_TYPE_EARLY_SKIP
7519 | OPTI_TYPE_NOT_ITERATED
7520 | OPTI_TYPE_PREPENDED_SALT
7521 | OPTI_TYPE_RAW_HASH;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 4;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 1;
7526 break;
7527
7528 case 125: hash_type = HASH_TYPE_SHA1;
7529 salt_type = SALT_TYPE_EMBEDDED;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15
7534 | OPTS_TYPE_ST_HEX;
7535 kern_type = KERN_TYPE_SHA1_SLTPW;
7536 dgst_size = DGST_SIZE_4_5;
7537 parse_func = arubaos_parse_hash;
7538 sort_by_digest = sort_by_digest_4_5;
7539 opti_type = OPTI_TYPE_ZERO_BYTE
7540 | OPTI_TYPE_PRECOMPUTE_INIT
7541 | OPTI_TYPE_PRECOMPUTE_MERKLE
7542 | OPTI_TYPE_EARLY_SKIP
7543 | OPTI_TYPE_NOT_ITERATED
7544 | OPTI_TYPE_PREPENDED_SALT
7545 | OPTI_TYPE_RAW_HASH;
7546 dgst_pos0 = 3;
7547 dgst_pos1 = 4;
7548 dgst_pos2 = 2;
7549 dgst_pos3 = 1;
7550 break;
7551
7552 case 130: hash_type = HASH_TYPE_SHA1;
7553 salt_type = SALT_TYPE_INTERN;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = OPTS_TYPE_PT_GENERATE_BE
7556 | OPTS_TYPE_PT_UNICODE
7557 | OPTS_TYPE_ST_ADD80
7558 | OPTS_TYPE_ST_ADDBITS15;
7559 kern_type = KERN_TYPE_SHA1_PWUSLT;
7560 dgst_size = DGST_SIZE_4_5;
7561 parse_func = sha1s_parse_hash;
7562 sort_by_digest = sort_by_digest_4_5;
7563 opti_type = OPTI_TYPE_ZERO_BYTE
7564 | OPTI_TYPE_PRECOMPUTE_INIT
7565 | OPTI_TYPE_PRECOMPUTE_MERKLE
7566 | OPTI_TYPE_EARLY_SKIP
7567 | OPTI_TYPE_NOT_ITERATED
7568 | OPTI_TYPE_APPENDED_SALT
7569 | OPTI_TYPE_RAW_HASH;
7570 dgst_pos0 = 3;
7571 dgst_pos1 = 4;
7572 dgst_pos2 = 2;
7573 dgst_pos3 = 1;
7574 break;
7575
7576 case 131: hash_type = HASH_TYPE_SHA1;
7577 salt_type = SALT_TYPE_EMBEDDED;
7578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7579 opts_type = OPTS_TYPE_PT_GENERATE_BE
7580 | OPTS_TYPE_PT_UNICODE
7581 | OPTS_TYPE_PT_UPPER
7582 | OPTS_TYPE_ST_ADD80
7583 | OPTS_TYPE_ST_ADDBITS15
7584 | OPTS_TYPE_ST_HEX;
7585 kern_type = KERN_TYPE_SHA1_PWUSLT;
7586 dgst_size = DGST_SIZE_4_5;
7587 parse_func = mssql2000_parse_hash;
7588 sort_by_digest = sort_by_digest_4_5;
7589 opti_type = OPTI_TYPE_ZERO_BYTE
7590 | OPTI_TYPE_PRECOMPUTE_INIT
7591 | OPTI_TYPE_PRECOMPUTE_MERKLE
7592 | OPTI_TYPE_EARLY_SKIP
7593 | OPTI_TYPE_NOT_ITERATED
7594 | OPTI_TYPE_APPENDED_SALT
7595 | OPTI_TYPE_RAW_HASH;
7596 dgst_pos0 = 3;
7597 dgst_pos1 = 4;
7598 dgst_pos2 = 2;
7599 dgst_pos3 = 1;
7600 break;
7601
7602 case 132: hash_type = HASH_TYPE_SHA1;
7603 salt_type = SALT_TYPE_EMBEDDED;
7604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7605 opts_type = OPTS_TYPE_PT_GENERATE_BE
7606 | OPTS_TYPE_PT_UNICODE
7607 | OPTS_TYPE_ST_ADD80
7608 | OPTS_TYPE_ST_ADDBITS15
7609 | OPTS_TYPE_ST_HEX;
7610 kern_type = KERN_TYPE_SHA1_PWUSLT;
7611 dgst_size = DGST_SIZE_4_5;
7612 parse_func = mssql2005_parse_hash;
7613 sort_by_digest = sort_by_digest_4_5;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED
7619 | OPTI_TYPE_APPENDED_SALT
7620 | OPTI_TYPE_RAW_HASH;
7621 dgst_pos0 = 3;
7622 dgst_pos1 = 4;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 1;
7625 break;
7626
7627 case 133: hash_type = HASH_TYPE_SHA1;
7628 salt_type = SALT_TYPE_EMBEDDED;
7629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_BE
7631 | OPTS_TYPE_PT_UNICODE
7632 | OPTS_TYPE_ST_ADD80
7633 | OPTS_TYPE_ST_ADDBITS15;
7634 kern_type = KERN_TYPE_SHA1_PWUSLT;
7635 dgst_size = DGST_SIZE_4_5;
7636 parse_func = peoplesoft_parse_hash;
7637 sort_by_digest = sort_by_digest_4_5;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_APPENDED_SALT
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 3;
7646 dgst_pos1 = 4;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 1;
7649 break;
7650
7651 case 140: hash_type = HASH_TYPE_SHA1;
7652 salt_type = SALT_TYPE_INTERN;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS15
7657 | OPTS_TYPE_PT_UNICODE;
7658 kern_type = KERN_TYPE_SHA1_SLTPWU;
7659 dgst_size = DGST_SIZE_4_5;
7660 parse_func = sha1s_parse_hash;
7661 sort_by_digest = sort_by_digest_4_5;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_PREPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 4;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 1;
7673 break;
7674
7675 case 141: hash_type = HASH_TYPE_SHA1;
7676 salt_type = SALT_TYPE_EMBEDDED;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_ADD80
7680 | OPTS_TYPE_PT_ADDBITS15
7681 | OPTS_TYPE_PT_UNICODE
7682 | OPTS_TYPE_ST_BASE64;
7683 kern_type = KERN_TYPE_SHA1_SLTPWU;
7684 dgst_size = DGST_SIZE_4_5;
7685 parse_func = episerver_parse_hash;
7686 sort_by_digest = sort_by_digest_4_5;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_PRECOMPUTE_MERKLE
7690 | OPTI_TYPE_EARLY_SKIP
7691 | OPTI_TYPE_NOT_ITERATED
7692 | OPTI_TYPE_PREPENDED_SALT
7693 | OPTI_TYPE_RAW_HASH;
7694 dgst_pos0 = 3;
7695 dgst_pos1 = 4;
7696 dgst_pos2 = 2;
7697 dgst_pos3 = 1;
7698 break;
7699
7700 case 150: hash_type = HASH_TYPE_SHA1;
7701 salt_type = SALT_TYPE_INTERN;
7702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7703 opts_type = OPTS_TYPE_PT_GENERATE_BE
7704 | OPTS_TYPE_ST_ADD80
7705 | OPTS_TYPE_ST_ADDBITS15;
7706 kern_type = KERN_TYPE_HMACSHA1_PW;
7707 dgst_size = DGST_SIZE_4_5;
7708 parse_func = hmacsha1_parse_hash;
7709 sort_by_digest = sort_by_digest_4_5;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_NOT_ITERATED;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 160: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_PT_ADD80
7723 | OPTS_TYPE_PT_ADDBITS15;
7724 kern_type = KERN_TYPE_HMACSHA1_SLT;
7725 dgst_size = DGST_SIZE_4_5;
7726 parse_func = hmacsha1_parse_hash;
7727 sort_by_digest = sort_by_digest_4_5;
7728 opti_type = OPTI_TYPE_ZERO_BYTE
7729 | OPTI_TYPE_NOT_ITERATED;
7730 dgst_pos0 = 3;
7731 dgst_pos1 = 4;
7732 dgst_pos2 = 2;
7733 dgst_pos3 = 1;
7734 break;
7735
7736 case 190: hash_type = HASH_TYPE_SHA1;
7737 salt_type = SALT_TYPE_NONE;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_PT_ADD80
7741 | OPTS_TYPE_PT_ADDBITS15;
7742 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7743 dgst_size = DGST_SIZE_4_5;
7744 parse_func = sha1linkedin_parse_hash;
7745 sort_by_digest = sort_by_digest_4_5;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_EARLY_SKIP
7749 | OPTI_TYPE_NOT_ITERATED
7750 | OPTI_TYPE_NOT_SALTED;
7751 dgst_pos0 = 0;
7752 dgst_pos1 = 4;
7753 dgst_pos2 = 3;
7754 dgst_pos3 = 2;
7755 break;
7756
7757 case 200: hash_type = HASH_TYPE_MYSQL;
7758 salt_type = SALT_TYPE_NONE;
7759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7760 opts_type = 0;
7761 kern_type = KERN_TYPE_MYSQL;
7762 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7763 parse_func = mysql323_parse_hash;
7764 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7765 opti_type = OPTI_TYPE_ZERO_BYTE;
7766 dgst_pos0 = 0;
7767 dgst_pos1 = 1;
7768 dgst_pos2 = 2;
7769 dgst_pos3 = 3;
7770 break;
7771
7772 case 300: hash_type = HASH_TYPE_SHA1;
7773 salt_type = SALT_TYPE_NONE;
7774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7775 opts_type = OPTS_TYPE_PT_GENERATE_BE
7776 | OPTS_TYPE_PT_ADD80
7777 | OPTS_TYPE_PT_ADDBITS15;
7778 kern_type = KERN_TYPE_MYSQL41;
7779 dgst_size = DGST_SIZE_4_5;
7780 parse_func = sha1_parse_hash;
7781 sort_by_digest = sort_by_digest_4_5;
7782 opti_type = OPTI_TYPE_ZERO_BYTE
7783 | OPTI_TYPE_PRECOMPUTE_INIT
7784 | OPTI_TYPE_PRECOMPUTE_MERKLE
7785 | OPTI_TYPE_EARLY_SKIP
7786 | OPTI_TYPE_NOT_ITERATED
7787 | OPTI_TYPE_NOT_SALTED;
7788 dgst_pos0 = 3;
7789 dgst_pos1 = 4;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 1;
7792 break;
7793
7794 case 400: hash_type = HASH_TYPE_MD5;
7795 salt_type = SALT_TYPE_EMBEDDED;
7796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7797 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7798 kern_type = KERN_TYPE_PHPASS;
7799 dgst_size = DGST_SIZE_4_4;
7800 parse_func = phpass_parse_hash;
7801 sort_by_digest = sort_by_digest_4_4;
7802 opti_type = OPTI_TYPE_ZERO_BYTE
7803 | OPTI_TYPE_SLOW_HASH_SIMD;
7804 dgst_pos0 = 0;
7805 dgst_pos1 = 1;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 3;
7808 break;
7809
7810 case 500: hash_type = HASH_TYPE_MD5;
7811 salt_type = SALT_TYPE_EMBEDDED;
7812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7814 kern_type = KERN_TYPE_MD5CRYPT;
7815 dgst_size = DGST_SIZE_4_4;
7816 parse_func = md5crypt_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4;
7818 opti_type = OPTI_TYPE_ZERO_BYTE;
7819 dgst_pos0 = 0;
7820 dgst_pos1 = 1;
7821 dgst_pos2 = 2;
7822 dgst_pos3 = 3;
7823 break;
7824
7825 case 501: hash_type = HASH_TYPE_MD5;
7826 salt_type = SALT_TYPE_EMBEDDED;
7827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7828 opts_type = OPTS_TYPE_PT_GENERATE_LE
7829 | OPTS_TYPE_HASH_COPY;
7830 kern_type = KERN_TYPE_MD5CRYPT;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = juniper_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE;
7835 dgst_pos0 = 0;
7836 dgst_pos1 = 1;
7837 dgst_pos2 = 2;
7838 dgst_pos3 = 3;
7839 break;
7840
7841 case 900: hash_type = HASH_TYPE_MD4;
7842 salt_type = SALT_TYPE_NONE;
7843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7844 opts_type = OPTS_TYPE_PT_GENERATE_LE
7845 | OPTS_TYPE_PT_ADD80
7846 | OPTS_TYPE_PT_ADDBITS14;
7847 kern_type = KERN_TYPE_MD4;
7848 dgst_size = DGST_SIZE_4_4;
7849 parse_func = md4_parse_hash;
7850 sort_by_digest = sort_by_digest_4_4;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_MEET_IN_MIDDLE
7855 | OPTI_TYPE_EARLY_SKIP
7856 | OPTI_TYPE_NOT_ITERATED
7857 | OPTI_TYPE_NOT_SALTED
7858 | OPTI_TYPE_RAW_HASH;
7859 dgst_pos0 = 0;
7860 dgst_pos1 = 3;
7861 dgst_pos2 = 2;
7862 dgst_pos3 = 1;
7863 break;
7864
7865 case 1000: hash_type = HASH_TYPE_MD4;
7866 salt_type = SALT_TYPE_NONE;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_LE
7869 | OPTS_TYPE_PT_ADD80
7870 | OPTS_TYPE_PT_ADDBITS14
7871 | OPTS_TYPE_PT_UNICODE;
7872 kern_type = KERN_TYPE_MD4_PWU;
7873 dgst_size = DGST_SIZE_4_4;
7874 parse_func = md4_parse_hash;
7875 sort_by_digest = sort_by_digest_4_4;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_MEET_IN_MIDDLE
7880 | OPTI_TYPE_EARLY_SKIP
7881 | OPTI_TYPE_NOT_ITERATED
7882 | OPTI_TYPE_NOT_SALTED
7883 | OPTI_TYPE_RAW_HASH;
7884 dgst_pos0 = 0;
7885 dgst_pos1 = 3;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 1;
7888 break;
7889
7890 case 1100: hash_type = HASH_TYPE_MD4;
7891 salt_type = SALT_TYPE_INTERN;
7892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_LE
7894 | OPTS_TYPE_PT_ADD80
7895 | OPTS_TYPE_PT_ADDBITS14
7896 | OPTS_TYPE_PT_UNICODE
7897 | OPTS_TYPE_ST_ADD80
7898 | OPTS_TYPE_ST_UNICODE
7899 | OPTS_TYPE_ST_LOWER;
7900 kern_type = KERN_TYPE_MD44_PWUSLT;
7901 dgst_size = DGST_SIZE_4_4;
7902 parse_func = dcc_parse_hash;
7903 sort_by_digest = sort_by_digest_4_4;
7904 opti_type = OPTI_TYPE_ZERO_BYTE
7905 | OPTI_TYPE_PRECOMPUTE_INIT
7906 | OPTI_TYPE_PRECOMPUTE_MERKLE
7907 | OPTI_TYPE_EARLY_SKIP
7908 | OPTI_TYPE_NOT_ITERATED;
7909 dgst_pos0 = 0;
7910 dgst_pos1 = 3;
7911 dgst_pos2 = 2;
7912 dgst_pos3 = 1;
7913 break;
7914
7915 case 1400: hash_type = HASH_TYPE_SHA256;
7916 salt_type = SALT_TYPE_NONE;
7917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7918 opts_type = OPTS_TYPE_PT_GENERATE_BE
7919 | OPTS_TYPE_PT_ADD80
7920 | OPTS_TYPE_PT_ADDBITS15;
7921 kern_type = KERN_TYPE_SHA256;
7922 dgst_size = DGST_SIZE_4_8;
7923 parse_func = sha256_parse_hash;
7924 sort_by_digest = sort_by_digest_4_8;
7925 opti_type = OPTI_TYPE_ZERO_BYTE
7926 | OPTI_TYPE_PRECOMPUTE_INIT
7927 | OPTI_TYPE_PRECOMPUTE_MERKLE
7928 | OPTI_TYPE_EARLY_SKIP
7929 | OPTI_TYPE_NOT_ITERATED
7930 | OPTI_TYPE_NOT_SALTED
7931 | OPTI_TYPE_RAW_HASH;
7932 dgst_pos0 = 3;
7933 dgst_pos1 = 7;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 6;
7936 break;
7937
7938 case 1410: hash_type = HASH_TYPE_SHA256;
7939 salt_type = SALT_TYPE_INTERN;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_BE
7942 | OPTS_TYPE_ST_ADD80
7943 | OPTS_TYPE_ST_ADDBITS15;
7944 kern_type = KERN_TYPE_SHA256_PWSLT;
7945 dgst_size = DGST_SIZE_4_8;
7946 parse_func = sha256s_parse_hash;
7947 sort_by_digest = sort_by_digest_4_8;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_APPENDED_SALT
7954 | OPTI_TYPE_RAW_HASH;
7955 dgst_pos0 = 3;
7956 dgst_pos1 = 7;
7957 dgst_pos2 = 2;
7958 dgst_pos3 = 6;
7959 break;
7960
7961 case 1420: hash_type = HASH_TYPE_SHA256;
7962 salt_type = SALT_TYPE_INTERN;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_PT_ADD80
7966 | OPTS_TYPE_PT_ADDBITS15;
7967 kern_type = KERN_TYPE_SHA256_SLTPW;
7968 dgst_size = DGST_SIZE_4_8;
7969 parse_func = sha256s_parse_hash;
7970 sort_by_digest = sort_by_digest_4_8;
7971 opti_type = OPTI_TYPE_ZERO_BYTE
7972 | OPTI_TYPE_PRECOMPUTE_INIT
7973 | OPTI_TYPE_PRECOMPUTE_MERKLE
7974 | OPTI_TYPE_EARLY_SKIP
7975 | OPTI_TYPE_NOT_ITERATED
7976 | OPTI_TYPE_PREPENDED_SALT
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 3;
7979 dgst_pos1 = 7;
7980 dgst_pos2 = 2;
7981 dgst_pos3 = 6;
7982 break;
7983
7984 case 1421: hash_type = HASH_TYPE_SHA256;
7985 salt_type = SALT_TYPE_EMBEDDED;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_PT_ADD80
7989 | OPTS_TYPE_PT_ADDBITS15;
7990 kern_type = KERN_TYPE_SHA256_SLTPW;
7991 dgst_size = DGST_SIZE_4_8;
7992 parse_func = hmailserver_parse_hash;
7993 sort_by_digest = sort_by_digest_4_8;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_PRECOMPUTE_INIT
7996 | OPTI_TYPE_PRECOMPUTE_MERKLE
7997 | OPTI_TYPE_EARLY_SKIP
7998 | OPTI_TYPE_NOT_ITERATED
7999 | OPTI_TYPE_PREPENDED_SALT
8000 | OPTI_TYPE_RAW_HASH;
8001 dgst_pos0 = 3;
8002 dgst_pos1 = 7;
8003 dgst_pos2 = 2;
8004 dgst_pos3 = 6;
8005 break;
8006
8007 case 1430: hash_type = HASH_TYPE_SHA256;
8008 salt_type = SALT_TYPE_INTERN;
8009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8010 opts_type = OPTS_TYPE_PT_GENERATE_BE
8011 | OPTS_TYPE_PT_UNICODE
8012 | OPTS_TYPE_ST_ADD80
8013 | OPTS_TYPE_ST_ADDBITS15;
8014 kern_type = KERN_TYPE_SHA256_PWUSLT;
8015 dgst_size = DGST_SIZE_4_8;
8016 parse_func = sha256s_parse_hash;
8017 sort_by_digest = sort_by_digest_4_8;
8018 opti_type = OPTI_TYPE_ZERO_BYTE
8019 | OPTI_TYPE_PRECOMPUTE_INIT
8020 | OPTI_TYPE_PRECOMPUTE_MERKLE
8021 | OPTI_TYPE_EARLY_SKIP
8022 | OPTI_TYPE_NOT_ITERATED
8023 | OPTI_TYPE_APPENDED_SALT
8024 | OPTI_TYPE_RAW_HASH;
8025 dgst_pos0 = 3;
8026 dgst_pos1 = 7;
8027 dgst_pos2 = 2;
8028 dgst_pos3 = 6;
8029 break;
8030
8031 case 1440: hash_type = HASH_TYPE_SHA256;
8032 salt_type = SALT_TYPE_INTERN;
8033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8034 opts_type = OPTS_TYPE_PT_GENERATE_BE
8035 | OPTS_TYPE_PT_ADD80
8036 | OPTS_TYPE_PT_ADDBITS15
8037 | OPTS_TYPE_PT_UNICODE;
8038 kern_type = KERN_TYPE_SHA256_SLTPWU;
8039 dgst_size = DGST_SIZE_4_8;
8040 parse_func = sha256s_parse_hash;
8041 sort_by_digest = sort_by_digest_4_8;
8042 opti_type = OPTI_TYPE_ZERO_BYTE
8043 | OPTI_TYPE_PRECOMPUTE_INIT
8044 | OPTI_TYPE_PRECOMPUTE_MERKLE
8045 | OPTI_TYPE_EARLY_SKIP
8046 | OPTI_TYPE_NOT_ITERATED
8047 | OPTI_TYPE_PREPENDED_SALT
8048 | OPTI_TYPE_RAW_HASH;
8049 dgst_pos0 = 3;
8050 dgst_pos1 = 7;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 6;
8053 break;
8054
8055 case 1441: hash_type = HASH_TYPE_SHA256;
8056 salt_type = SALT_TYPE_EMBEDDED;
8057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_BE
8059 | OPTS_TYPE_PT_ADD80
8060 | OPTS_TYPE_PT_ADDBITS15
8061 | OPTS_TYPE_PT_UNICODE
8062 | OPTS_TYPE_ST_BASE64;
8063 kern_type = KERN_TYPE_SHA256_SLTPWU;
8064 dgst_size = DGST_SIZE_4_8;
8065 parse_func = episerver4_parse_hash;
8066 sort_by_digest = sort_by_digest_4_8;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_INIT
8069 | OPTI_TYPE_PRECOMPUTE_MERKLE
8070 | OPTI_TYPE_EARLY_SKIP
8071 | OPTI_TYPE_NOT_ITERATED
8072 | OPTI_TYPE_PREPENDED_SALT
8073 | OPTI_TYPE_RAW_HASH;
8074 dgst_pos0 = 3;
8075 dgst_pos1 = 7;
8076 dgst_pos2 = 2;
8077 dgst_pos3 = 6;
8078 break;
8079
8080 case 1450: hash_type = HASH_TYPE_SHA256;
8081 salt_type = SALT_TYPE_INTERN;
8082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8083 opts_type = OPTS_TYPE_PT_GENERATE_BE
8084 | OPTS_TYPE_ST_ADD80;
8085 kern_type = KERN_TYPE_HMACSHA256_PW;
8086 dgst_size = DGST_SIZE_4_8;
8087 parse_func = hmacsha256_parse_hash;
8088 sort_by_digest = sort_by_digest_4_8;
8089 opti_type = OPTI_TYPE_ZERO_BYTE
8090 | OPTI_TYPE_NOT_ITERATED;
8091 dgst_pos0 = 3;
8092 dgst_pos1 = 7;
8093 dgst_pos2 = 2;
8094 dgst_pos3 = 6;
8095 break;
8096
8097 case 1460: hash_type = HASH_TYPE_SHA256;
8098 salt_type = SALT_TYPE_INTERN;
8099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8100 opts_type = OPTS_TYPE_PT_GENERATE_BE
8101 | OPTS_TYPE_PT_ADD80
8102 | OPTS_TYPE_PT_ADDBITS15;
8103 kern_type = KERN_TYPE_HMACSHA256_SLT;
8104 dgst_size = DGST_SIZE_4_8;
8105 parse_func = hmacsha256_parse_hash;
8106 sort_by_digest = sort_by_digest_4_8;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_NOT_ITERATED;
8109 dgst_pos0 = 3;
8110 dgst_pos1 = 7;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 6;
8113 break;
8114
8115 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8116 salt_type = SALT_TYPE_EMBEDDED;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_LE
8119 | OPTS_TYPE_PT_BITSLICE;
8120 kern_type = KERN_TYPE_DESCRYPT;
8121 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8122 parse_func = descrypt_parse_hash;
8123 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8124 opti_type = OPTI_TYPE_ZERO_BYTE
8125 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8126 dgst_pos0 = 0;
8127 dgst_pos1 = 1;
8128 dgst_pos2 = 2;
8129 dgst_pos3 = 3;
8130 break;
8131
8132 case 1600: hash_type = HASH_TYPE_MD5;
8133 salt_type = SALT_TYPE_EMBEDDED;
8134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8136 kern_type = KERN_TYPE_APR1CRYPT;
8137 dgst_size = DGST_SIZE_4_4;
8138 parse_func = md5apr1_parse_hash;
8139 sort_by_digest = sort_by_digest_4_4;
8140 opti_type = OPTI_TYPE_ZERO_BYTE;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 1;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 3;
8145 break;
8146
8147 case 1700: hash_type = HASH_TYPE_SHA512;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_BE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS15;
8153 kern_type = KERN_TYPE_SHA512;
8154 dgst_size = DGST_SIZE_8_8;
8155 parse_func = sha512_parse_hash;
8156 sort_by_digest = sort_by_digest_8_8;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_ITERATED
8162 | OPTI_TYPE_NOT_SALTED
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_RAW_HASH;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1710: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_ST_ADD80
8176 | OPTS_TYPE_ST_ADDBITS15;
8177 kern_type = KERN_TYPE_SHA512_PWSLT;
8178 dgst_size = DGST_SIZE_8_8;
8179 parse_func = sha512s_parse_hash;
8180 sort_by_digest = sort_by_digest_8_8;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_PRECOMPUTE_MERKLE
8184 | OPTI_TYPE_EARLY_SKIP
8185 | OPTI_TYPE_NOT_ITERATED
8186 | OPTI_TYPE_APPENDED_SALT
8187 | OPTI_TYPE_USES_BITS_64
8188 | OPTI_TYPE_RAW_HASH;
8189 dgst_pos0 = 14;
8190 dgst_pos1 = 15;
8191 dgst_pos2 = 6;
8192 dgst_pos3 = 7;
8193 break;
8194
8195 case 1711: hash_type = HASH_TYPE_SHA512;
8196 salt_type = SALT_TYPE_EMBEDDED;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_BE
8199 | OPTS_TYPE_ST_ADD80
8200 | OPTS_TYPE_ST_ADDBITS15;
8201 kern_type = KERN_TYPE_SHA512_PWSLT;
8202 dgst_size = DGST_SIZE_8_8;
8203 parse_func = sha512b64s_parse_hash;
8204 sort_by_digest = sort_by_digest_8_8;
8205 opti_type = OPTI_TYPE_ZERO_BYTE
8206 | OPTI_TYPE_PRECOMPUTE_INIT
8207 | OPTI_TYPE_PRECOMPUTE_MERKLE
8208 | OPTI_TYPE_EARLY_SKIP
8209 | OPTI_TYPE_NOT_ITERATED
8210 | OPTI_TYPE_APPENDED_SALT
8211 | OPTI_TYPE_USES_BITS_64
8212 | OPTI_TYPE_RAW_HASH;
8213 dgst_pos0 = 14;
8214 dgst_pos1 = 15;
8215 dgst_pos2 = 6;
8216 dgst_pos3 = 7;
8217 break;
8218
8219 case 1720: hash_type = HASH_TYPE_SHA512;
8220 salt_type = SALT_TYPE_INTERN;
8221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_BE
8223 | OPTS_TYPE_PT_ADD80
8224 | OPTS_TYPE_PT_ADDBITS15;
8225 kern_type = KERN_TYPE_SHA512_SLTPW;
8226 dgst_size = DGST_SIZE_8_8;
8227 parse_func = sha512s_parse_hash;
8228 sort_by_digest = sort_by_digest_8_8;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_PRECOMPUTE_INIT
8231 | OPTI_TYPE_PRECOMPUTE_MERKLE
8232 | OPTI_TYPE_EARLY_SKIP
8233 | OPTI_TYPE_NOT_ITERATED
8234 | OPTI_TYPE_PREPENDED_SALT
8235 | OPTI_TYPE_USES_BITS_64
8236 | OPTI_TYPE_RAW_HASH;
8237 dgst_pos0 = 14;
8238 dgst_pos1 = 15;
8239 dgst_pos2 = 6;
8240 dgst_pos3 = 7;
8241 break;
8242
8243 case 1722: hash_type = HASH_TYPE_SHA512;
8244 salt_type = SALT_TYPE_EMBEDDED;
8245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_BE
8247 | OPTS_TYPE_PT_ADD80
8248 | OPTS_TYPE_PT_ADDBITS15
8249 | OPTS_TYPE_ST_HEX;
8250 kern_type = KERN_TYPE_SHA512_SLTPW;
8251 dgst_size = DGST_SIZE_8_8;
8252 parse_func = osx512_parse_hash;
8253 sort_by_digest = sort_by_digest_8_8;
8254 opti_type = OPTI_TYPE_ZERO_BYTE
8255 | OPTI_TYPE_PRECOMPUTE_INIT
8256 | OPTI_TYPE_PRECOMPUTE_MERKLE
8257 | OPTI_TYPE_EARLY_SKIP
8258 | OPTI_TYPE_NOT_ITERATED
8259 | OPTI_TYPE_PREPENDED_SALT
8260 | OPTI_TYPE_USES_BITS_64
8261 | OPTI_TYPE_RAW_HASH;
8262 dgst_pos0 = 14;
8263 dgst_pos1 = 15;
8264 dgst_pos2 = 6;
8265 dgst_pos3 = 7;
8266 break;
8267
8268 case 1730: hash_type = HASH_TYPE_SHA512;
8269 salt_type = SALT_TYPE_INTERN;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_BE
8272 | OPTS_TYPE_PT_UNICODE
8273 | OPTS_TYPE_ST_ADD80
8274 | OPTS_TYPE_ST_ADDBITS15;
8275 kern_type = KERN_TYPE_SHA512_PWSLTU;
8276 dgst_size = DGST_SIZE_8_8;
8277 parse_func = sha512s_parse_hash;
8278 sort_by_digest = sort_by_digest_8_8;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_INIT
8281 | OPTI_TYPE_PRECOMPUTE_MERKLE
8282 | OPTI_TYPE_EARLY_SKIP
8283 | OPTI_TYPE_NOT_ITERATED
8284 | OPTI_TYPE_APPENDED_SALT
8285 | OPTI_TYPE_USES_BITS_64
8286 | OPTI_TYPE_RAW_HASH;
8287 dgst_pos0 = 14;
8288 dgst_pos1 = 15;
8289 dgst_pos2 = 6;
8290 dgst_pos3 = 7;
8291 break;
8292
8293 case 1731: hash_type = HASH_TYPE_SHA512;
8294 salt_type = SALT_TYPE_EMBEDDED;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_BE
8297 | OPTS_TYPE_PT_UNICODE
8298 | OPTS_TYPE_ST_ADD80
8299 | OPTS_TYPE_ST_ADDBITS15
8300 | OPTS_TYPE_ST_HEX;
8301 kern_type = KERN_TYPE_SHA512_PWSLTU;
8302 dgst_size = DGST_SIZE_8_8;
8303 parse_func = mssql2012_parse_hash;
8304 sort_by_digest = sort_by_digest_8_8;
8305 opti_type = OPTI_TYPE_ZERO_BYTE
8306 | OPTI_TYPE_PRECOMPUTE_INIT
8307 | OPTI_TYPE_PRECOMPUTE_MERKLE
8308 | OPTI_TYPE_EARLY_SKIP
8309 | OPTI_TYPE_NOT_ITERATED
8310 | OPTI_TYPE_APPENDED_SALT
8311 | OPTI_TYPE_USES_BITS_64
8312 | OPTI_TYPE_RAW_HASH;
8313 dgst_pos0 = 14;
8314 dgst_pos1 = 15;
8315 dgst_pos2 = 6;
8316 dgst_pos3 = 7;
8317 break;
8318
8319 case 1740: hash_type = HASH_TYPE_SHA512;
8320 salt_type = SALT_TYPE_INTERN;
8321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8322 opts_type = OPTS_TYPE_PT_GENERATE_BE
8323 | OPTS_TYPE_PT_ADD80
8324 | OPTS_TYPE_PT_ADDBITS15
8325 | OPTS_TYPE_PT_UNICODE;
8326 kern_type = KERN_TYPE_SHA512_SLTPWU;
8327 dgst_size = DGST_SIZE_8_8;
8328 parse_func = sha512s_parse_hash;
8329 sort_by_digest = sort_by_digest_8_8;
8330 opti_type = OPTI_TYPE_ZERO_BYTE
8331 | OPTI_TYPE_PRECOMPUTE_INIT
8332 | OPTI_TYPE_PRECOMPUTE_MERKLE
8333 | OPTI_TYPE_EARLY_SKIP
8334 | OPTI_TYPE_NOT_ITERATED
8335 | OPTI_TYPE_PREPENDED_SALT
8336 | OPTI_TYPE_USES_BITS_64
8337 | OPTI_TYPE_RAW_HASH;
8338 dgst_pos0 = 14;
8339 dgst_pos1 = 15;
8340 dgst_pos2 = 6;
8341 dgst_pos3 = 7;
8342 break;
8343
8344 case 1750: hash_type = HASH_TYPE_SHA512;
8345 salt_type = SALT_TYPE_INTERN;
8346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8347 opts_type = OPTS_TYPE_PT_GENERATE_BE
8348 | OPTS_TYPE_ST_ADD80;
8349 kern_type = KERN_TYPE_HMACSHA512_PW;
8350 dgst_size = DGST_SIZE_8_8;
8351 parse_func = hmacsha512_parse_hash;
8352 sort_by_digest = sort_by_digest_8_8;
8353 opti_type = OPTI_TYPE_ZERO_BYTE
8354 | OPTI_TYPE_USES_BITS_64
8355 | OPTI_TYPE_NOT_ITERATED;
8356 dgst_pos0 = 14;
8357 dgst_pos1 = 15;
8358 dgst_pos2 = 6;
8359 dgst_pos3 = 7;
8360 break;
8361
8362 case 1760: hash_type = HASH_TYPE_SHA512;
8363 salt_type = SALT_TYPE_INTERN;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_BE
8366 | OPTS_TYPE_PT_ADD80
8367 | OPTS_TYPE_PT_ADDBITS15;
8368 kern_type = KERN_TYPE_HMACSHA512_SLT;
8369 dgst_size = DGST_SIZE_8_8;
8370 parse_func = hmacsha512_parse_hash;
8371 sort_by_digest = sort_by_digest_8_8;
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_USES_BITS_64
8374 | OPTI_TYPE_NOT_ITERATED;
8375 dgst_pos0 = 14;
8376 dgst_pos1 = 15;
8377 dgst_pos2 = 6;
8378 dgst_pos3 = 7;
8379 break;
8380
8381 case 1800: hash_type = HASH_TYPE_SHA512;
8382 salt_type = SALT_TYPE_EMBEDDED;
8383 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8385 kern_type = KERN_TYPE_SHA512CRYPT;
8386 dgst_size = DGST_SIZE_8_8;
8387 parse_func = sha512crypt_parse_hash;
8388 sort_by_digest = sort_by_digest_8_8;
8389 opti_type = OPTI_TYPE_ZERO_BYTE
8390 | OPTI_TYPE_USES_BITS_64;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 1;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 3;
8395 break;
8396
8397 case 2100: hash_type = HASH_TYPE_DCC2;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8401 | OPTS_TYPE_ST_LOWER
8402 | OPTS_TYPE_ST_UNICODE;
8403 kern_type = KERN_TYPE_DCC2;
8404 dgst_size = DGST_SIZE_4_4;
8405 parse_func = dcc2_parse_hash;
8406 sort_by_digest = sort_by_digest_4_4;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_SLOW_HASH_SIMD;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 2400: hash_type = HASH_TYPE_MD5;
8416 salt_type = SALT_TYPE_NONE;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8419 kern_type = KERN_TYPE_MD5PIX;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5pix_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP
8427 | OPTI_TYPE_NOT_ITERATED
8428 | OPTI_TYPE_NOT_SALTED;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 3;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 1;
8433 break;
8434
8435 case 2410: hash_type = HASH_TYPE_MD5;
8436 salt_type = SALT_TYPE_INTERN;
8437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8439 kern_type = KERN_TYPE_MD5ASA;
8440 dgst_size = DGST_SIZE_4_4;
8441 parse_func = md5asa_parse_hash;
8442 sort_by_digest = sort_by_digest_4_4;
8443 opti_type = OPTI_TYPE_ZERO_BYTE
8444 | OPTI_TYPE_PRECOMPUTE_INIT
8445 | OPTI_TYPE_PRECOMPUTE_MERKLE
8446 | OPTI_TYPE_EARLY_SKIP
8447 | OPTI_TYPE_NOT_ITERATED;
8448 dgst_pos0 = 0;
8449 dgst_pos1 = 3;
8450 dgst_pos2 = 2;
8451 dgst_pos3 = 1;
8452 break;
8453
8454 case 2500: hash_type = HASH_TYPE_WPA;
8455 salt_type = SALT_TYPE_EMBEDDED;
8456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8457 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8458 kern_type = KERN_TYPE_WPA;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = wpa_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_SLOW_HASH_SIMD;
8464 dgst_pos0 = 0;
8465 dgst_pos1 = 1;
8466 dgst_pos2 = 2;
8467 dgst_pos3 = 3;
8468 break;
8469
8470 case 2600: hash_type = HASH_TYPE_MD5;
8471 salt_type = SALT_TYPE_VIRTUAL;
8472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8473 opts_type = OPTS_TYPE_PT_GENERATE_LE
8474 | OPTS_TYPE_PT_ADD80
8475 | OPTS_TYPE_PT_ADDBITS14
8476 | OPTS_TYPE_ST_ADD80;
8477 kern_type = KERN_TYPE_MD55_PWSLT1;
8478 dgst_size = DGST_SIZE_4_4;
8479 parse_func = md5md5_parse_hash;
8480 sort_by_digest = sort_by_digest_4_4;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP;
8485 dgst_pos0 = 0;
8486 dgst_pos1 = 3;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 1;
8489 break;
8490
8491 case 2611: hash_type = HASH_TYPE_MD5;
8492 salt_type = SALT_TYPE_INTERN;
8493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_LE
8495 | OPTS_TYPE_PT_ADD80
8496 | OPTS_TYPE_PT_ADDBITS14
8497 | OPTS_TYPE_ST_ADD80;
8498 kern_type = KERN_TYPE_MD55_PWSLT1;
8499 dgst_size = DGST_SIZE_4_4;
8500 parse_func = vb3_parse_hash;
8501 sort_by_digest = sort_by_digest_4_4;
8502 opti_type = OPTI_TYPE_ZERO_BYTE
8503 | OPTI_TYPE_PRECOMPUTE_INIT
8504 | OPTI_TYPE_PRECOMPUTE_MERKLE
8505 | OPTI_TYPE_EARLY_SKIP;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 2612: hash_type = HASH_TYPE_MD5;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADD80
8517 | OPTS_TYPE_PT_ADDBITS14
8518 | OPTS_TYPE_ST_ADD80
8519 | OPTS_TYPE_ST_HEX;
8520 kern_type = KERN_TYPE_MD55_PWSLT1;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = phps_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_PRECOMPUTE_MERKLE
8527 | OPTI_TYPE_EARLY_SKIP;
8528 dgst_pos0 = 0;
8529 dgst_pos1 = 3;
8530 dgst_pos2 = 2;
8531 dgst_pos3 = 1;
8532 break;
8533
8534 case 2711: hash_type = HASH_TYPE_MD5;
8535 salt_type = SALT_TYPE_INTERN;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE
8538 | OPTS_TYPE_PT_ADD80
8539 | OPTS_TYPE_PT_ADDBITS14
8540 | OPTS_TYPE_ST_ADD80;
8541 kern_type = KERN_TYPE_MD55_PWSLT2;
8542 dgst_size = DGST_SIZE_4_4;
8543 parse_func = vb30_parse_hash;
8544 sort_by_digest = sort_by_digest_4_4;
8545 opti_type = OPTI_TYPE_ZERO_BYTE
8546 | OPTI_TYPE_PRECOMPUTE_INIT
8547 | OPTI_TYPE_EARLY_SKIP;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 3;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 1;
8552 break;
8553
8554 case 2811: hash_type = HASH_TYPE_MD5;
8555 salt_type = SALT_TYPE_INTERN;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE
8558 | OPTS_TYPE_PT_ADD80
8559 | OPTS_TYPE_PT_ADDBITS14;
8560 kern_type = KERN_TYPE_MD55_SLTPW;
8561 dgst_size = DGST_SIZE_4_4;
8562 parse_func = ipb2_parse_hash;
8563 sort_by_digest = sort_by_digest_4_4;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_EARLY_SKIP;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 3;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 1;
8571 break;
8572
8573 case 3000: hash_type = HASH_TYPE_LM;
8574 salt_type = SALT_TYPE_NONE;
8575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE
8577 | OPTS_TYPE_PT_UPPER
8578 | OPTS_TYPE_PT_BITSLICE;
8579 kern_type = KERN_TYPE_LM;
8580 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8581 parse_func = lm_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 1;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 3;
8589 break;
8590
8591 case 3100: hash_type = HASH_TYPE_ORACLEH;
8592 salt_type = SALT_TYPE_INTERN;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_UPPER
8596 | OPTS_TYPE_ST_UPPER;
8597 kern_type = KERN_TYPE_ORACLEH;
8598 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8599 parse_func = oracleh_parse_hash;
8600 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8601 opti_type = OPTI_TYPE_ZERO_BYTE;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 3200: hash_type = HASH_TYPE_BCRYPT;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE
8612 | OPTS_TYPE_ST_GENERATE_LE;
8613 kern_type = KERN_TYPE_BCRYPT;
8614 dgst_size = DGST_SIZE_4_6;
8615 parse_func = bcrypt_parse_hash;
8616 sort_by_digest = sort_by_digest_4_6;
8617 opti_type = OPTI_TYPE_ZERO_BYTE;
8618 dgst_pos0 = 0;
8619 dgst_pos1 = 1;
8620 dgst_pos2 = 2;
8621 dgst_pos3 = 3;
8622 break;
8623
8624 case 3710: hash_type = HASH_TYPE_MD5;
8625 salt_type = SALT_TYPE_INTERN;
8626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE
8628 | OPTS_TYPE_PT_ADD80
8629 | OPTS_TYPE_PT_ADDBITS14;
8630 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8631 dgst_size = DGST_SIZE_4_4;
8632 parse_func = md5s_parse_hash;
8633 sort_by_digest = sort_by_digest_4_4;
8634 opti_type = OPTI_TYPE_ZERO_BYTE
8635 | OPTI_TYPE_PRECOMPUTE_INIT
8636 | OPTI_TYPE_PRECOMPUTE_MERKLE
8637 | OPTI_TYPE_EARLY_SKIP;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 3;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 1;
8642 break;
8643
8644 case 3711: hash_type = HASH_TYPE_MD5;
8645 salt_type = SALT_TYPE_EMBEDDED;
8646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_LE
8648 | OPTS_TYPE_PT_ADD80
8649 | OPTS_TYPE_PT_ADDBITS14;
8650 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8651 dgst_size = DGST_SIZE_4_4;
8652 parse_func = mediawiki_b_parse_hash;
8653 sort_by_digest = sort_by_digest_4_4;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_PRECOMPUTE_INIT
8656 | OPTI_TYPE_PRECOMPUTE_MERKLE
8657 | OPTI_TYPE_EARLY_SKIP;
8658 dgst_pos0 = 0;
8659 dgst_pos1 = 3;
8660 dgst_pos2 = 2;
8661 dgst_pos3 = 1;
8662 break;
8663
8664 case 3800: hash_type = HASH_TYPE_MD5;
8665 salt_type = SALT_TYPE_INTERN;
8666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8667 opts_type = OPTS_TYPE_PT_GENERATE_LE
8668 | OPTS_TYPE_ST_ADDBITS14;
8669 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8670 dgst_size = DGST_SIZE_4_4;
8671 parse_func = md5s_parse_hash;
8672 sort_by_digest = sort_by_digest_4_4;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_RAW_HASH;
8679 dgst_pos0 = 0;
8680 dgst_pos1 = 3;
8681 dgst_pos2 = 2;
8682 dgst_pos3 = 1;
8683 break;
8684
8685 case 4300: hash_type = HASH_TYPE_MD5;
8686 salt_type = SALT_TYPE_VIRTUAL;
8687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8688 opts_type = OPTS_TYPE_PT_GENERATE_LE
8689 | OPTS_TYPE_PT_ADD80
8690 | OPTS_TYPE_PT_ADDBITS14
8691 | OPTS_TYPE_ST_ADD80;
8692 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8693 dgst_size = DGST_SIZE_4_4;
8694 parse_func = md5md5_parse_hash;
8695 sort_by_digest = sort_by_digest_4_4;
8696 opti_type = OPTI_TYPE_ZERO_BYTE
8697 | OPTI_TYPE_PRECOMPUTE_INIT
8698 | OPTI_TYPE_PRECOMPUTE_MERKLE
8699 | OPTI_TYPE_EARLY_SKIP;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 3;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 1;
8704 break;
8705
8706
8707 case 4400: hash_type = HASH_TYPE_MD5;
8708 salt_type = SALT_TYPE_NONE;
8709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_BE
8711 | OPTS_TYPE_PT_ADD80
8712 | OPTS_TYPE_PT_ADDBITS15;
8713 kern_type = KERN_TYPE_MD5_SHA1;
8714 dgst_size = DGST_SIZE_4_4;
8715 parse_func = md5_parse_hash;
8716 sort_by_digest = sort_by_digest_4_4;
8717 opti_type = OPTI_TYPE_ZERO_BYTE
8718 | OPTI_TYPE_PRECOMPUTE_INIT
8719 | OPTI_TYPE_PRECOMPUTE_MERKLE
8720 | OPTI_TYPE_EARLY_SKIP
8721 | OPTI_TYPE_NOT_ITERATED
8722 | OPTI_TYPE_NOT_SALTED
8723 | OPTI_TYPE_RAW_HASH;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 3;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 1;
8728 break;
8729
8730 case 4500: hash_type = HASH_TYPE_SHA1;
8731 salt_type = SALT_TYPE_NONE;
8732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_BE
8734 | OPTS_TYPE_PT_ADD80
8735 | OPTS_TYPE_PT_ADDBITS15;
8736 kern_type = KERN_TYPE_SHA11;
8737 dgst_size = DGST_SIZE_4_5;
8738 parse_func = sha1_parse_hash;
8739 sort_by_digest = sort_by_digest_4_5;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_PRECOMPUTE_INIT
8742 | OPTI_TYPE_PRECOMPUTE_MERKLE
8743 | OPTI_TYPE_EARLY_SKIP
8744 | OPTI_TYPE_NOT_SALTED;
8745 dgst_pos0 = 3;
8746 dgst_pos1 = 4;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 1;
8749 break;
8750
8751 case 4700: hash_type = HASH_TYPE_SHA1;
8752 salt_type = SALT_TYPE_NONE;
8753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE
8755 | OPTS_TYPE_PT_ADD80
8756 | OPTS_TYPE_PT_ADDBITS14;
8757 kern_type = KERN_TYPE_SHA1_MD5;
8758 dgst_size = DGST_SIZE_4_5;
8759 parse_func = sha1_parse_hash;
8760 sort_by_digest = sort_by_digest_4_5;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_PRECOMPUTE_INIT
8763 | OPTI_TYPE_PRECOMPUTE_MERKLE
8764 | OPTI_TYPE_EARLY_SKIP
8765 | OPTI_TYPE_NOT_ITERATED
8766 | OPTI_TYPE_NOT_SALTED
8767 | OPTI_TYPE_RAW_HASH;
8768 dgst_pos0 = 3;
8769 dgst_pos1 = 4;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 4800: hash_type = HASH_TYPE_MD5;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADDBITS14;
8779 kern_type = KERN_TYPE_MD5_CHAP;
8780 dgst_size = DGST_SIZE_4_4;
8781 parse_func = chap_parse_hash;
8782 sort_by_digest = sort_by_digest_4_4;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_PRECOMPUTE_INIT
8785 | OPTI_TYPE_PRECOMPUTE_MERKLE
8786 | OPTI_TYPE_MEET_IN_MIDDLE
8787 | OPTI_TYPE_EARLY_SKIP
8788 | OPTI_TYPE_NOT_ITERATED
8789 | OPTI_TYPE_RAW_HASH;
8790 dgst_pos0 = 0;
8791 dgst_pos1 = 3;
8792 dgst_pos2 = 2;
8793 dgst_pos3 = 1;
8794 break;
8795
8796 case 4900: hash_type = HASH_TYPE_SHA1;
8797 salt_type = SALT_TYPE_INTERN;
8798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8799 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8800 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8801 dgst_size = DGST_SIZE_4_5;
8802 parse_func = sha1s_parse_hash;
8803 sort_by_digest = sort_by_digest_4_5;
8804 opti_type = OPTI_TYPE_ZERO_BYTE
8805 | OPTI_TYPE_PRECOMPUTE_INIT
8806 | OPTI_TYPE_PRECOMPUTE_MERKLE
8807 | OPTI_TYPE_EARLY_SKIP;
8808 dgst_pos0 = 3;
8809 dgst_pos1 = 4;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 1;
8812 break;
8813
8814 case 5000: hash_type = HASH_TYPE_KECCAK;
8815 salt_type = SALT_TYPE_EMBEDDED;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE
8818 | OPTS_TYPE_PT_ADD01;
8819 kern_type = KERN_TYPE_KECCAK;
8820 dgst_size = DGST_SIZE_8_25;
8821 parse_func = keccak_parse_hash;
8822 sort_by_digest = sort_by_digest_8_25;
8823 opti_type = OPTI_TYPE_ZERO_BYTE
8824 | OPTI_TYPE_USES_BITS_64
8825 | OPTI_TYPE_RAW_HASH;
8826 dgst_pos0 = 2;
8827 dgst_pos1 = 3;
8828 dgst_pos2 = 4;
8829 dgst_pos3 = 5;
8830 break;
8831
8832 case 5100: hash_type = HASH_TYPE_MD5H;
8833 salt_type = SALT_TYPE_NONE;
8834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE
8836 | OPTS_TYPE_PT_ADD80
8837 | OPTS_TYPE_PT_ADDBITS14;
8838 kern_type = KERN_TYPE_MD5H;
8839 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8840 parse_func = md5half_parse_hash;
8841 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8842 opti_type = OPTI_TYPE_ZERO_BYTE
8843 | OPTI_TYPE_RAW_HASH;
8844 dgst_pos0 = 0;
8845 dgst_pos1 = 1;
8846 dgst_pos2 = 2;
8847 dgst_pos3 = 3;
8848 break;
8849
8850 case 5200: hash_type = HASH_TYPE_SHA256;
8851 salt_type = SALT_TYPE_EMBEDDED;
8852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8853 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8854 kern_type = KERN_TYPE_PSAFE3;
8855 dgst_size = DGST_SIZE_4_8;
8856 parse_func = psafe3_parse_hash;
8857 sort_by_digest = sort_by_digest_4_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 1;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 3;
8863 break;
8864
8865 case 5300: hash_type = HASH_TYPE_MD5;
8866 salt_type = SALT_TYPE_EMBEDDED;
8867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_LE
8869 | OPTS_TYPE_ST_ADD80;
8870 kern_type = KERN_TYPE_IKEPSK_MD5;
8871 dgst_size = DGST_SIZE_4_4;
8872 parse_func = ikepsk_md5_parse_hash;
8873 sort_by_digest = sort_by_digest_4_4;
8874 opti_type = OPTI_TYPE_ZERO_BYTE;
8875 dgst_pos0 = 0;
8876 dgst_pos1 = 3;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 1;
8879 break;
8880
8881 case 5400: hash_type = HASH_TYPE_SHA1;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_BE
8885 | OPTS_TYPE_ST_ADD80;
8886 kern_type = KERN_TYPE_IKEPSK_SHA1;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = ikepsk_sha1_parse_hash;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 3;
8892 dgst_pos1 = 4;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 1;
8895 break;
8896
8897 case 5500: hash_type = HASH_TYPE_NETNTLM;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE
8901 | OPTS_TYPE_PT_ADD80
8902 | OPTS_TYPE_PT_ADDBITS14
8903 | OPTS_TYPE_PT_UNICODE
8904 | OPTS_TYPE_ST_HEX;
8905 kern_type = KERN_TYPE_NETNTLMv1;
8906 dgst_size = DGST_SIZE_4_4;
8907 parse_func = netntlmv1_parse_hash;
8908 sort_by_digest = sort_by_digest_4_4;
8909 opti_type = OPTI_TYPE_ZERO_BYTE
8910 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8911 dgst_pos0 = 0;
8912 dgst_pos1 = 1;
8913 dgst_pos2 = 2;
8914 dgst_pos3 = 3;
8915 break;
8916
8917 case 5600: hash_type = HASH_TYPE_MD5;
8918 salt_type = SALT_TYPE_EMBEDDED;
8919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8920 opts_type = OPTS_TYPE_PT_GENERATE_LE
8921 | OPTS_TYPE_PT_ADD80
8922 | OPTS_TYPE_PT_ADDBITS14
8923 | OPTS_TYPE_PT_UNICODE;
8924 kern_type = KERN_TYPE_NETNTLMv2;
8925 dgst_size = DGST_SIZE_4_4;
8926 parse_func = netntlmv2_parse_hash;
8927 sort_by_digest = sort_by_digest_4_4;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 0;
8930 dgst_pos1 = 3;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 5700: hash_type = HASH_TYPE_SHA256;
8936 salt_type = SALT_TYPE_NONE;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_BE
8939 | OPTS_TYPE_PT_ADD80
8940 | OPTS_TYPE_PT_ADDBITS15;
8941 kern_type = KERN_TYPE_SHA256;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = cisco4_parse_hash;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_INIT
8947 | OPTI_TYPE_PRECOMPUTE_MERKLE
8948 | OPTI_TYPE_EARLY_SKIP
8949 | OPTI_TYPE_NOT_ITERATED
8950 | OPTI_TYPE_NOT_SALTED
8951 | OPTI_TYPE_RAW_HASH;
8952 dgst_pos0 = 3;
8953 dgst_pos1 = 7;
8954 dgst_pos2 = 2;
8955 dgst_pos3 = 6;
8956 break;
8957
8958 case 5800: hash_type = HASH_TYPE_SHA1;
8959 salt_type = SALT_TYPE_INTERN;
8960 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8961 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8962 | OPTS_TYPE_ST_ADD80;
8963 kern_type = KERN_TYPE_ANDROIDPIN;
8964 dgst_size = DGST_SIZE_4_5;
8965 parse_func = androidpin_parse_hash;
8966 sort_by_digest = sort_by_digest_4_5;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8975 salt_type = SALT_TYPE_NONE;
8976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE
8978 | OPTS_TYPE_PT_ADD80;
8979 kern_type = KERN_TYPE_RIPEMD160;
8980 dgst_size = DGST_SIZE_4_5;
8981 parse_func = ripemd160_parse_hash;
8982 sort_by_digest = sort_by_digest_4_5;
8983 opti_type = OPTI_TYPE_ZERO_BYTE;
8984 dgst_pos0 = 0;
8985 dgst_pos1 = 1;
8986 dgst_pos2 = 2;
8987 dgst_pos3 = 3;
8988 break;
8989
8990 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8991 salt_type = SALT_TYPE_NONE;
8992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_BE
8994 | OPTS_TYPE_PT_ADD80;
8995 kern_type = KERN_TYPE_WHIRLPOOL;
8996 dgst_size = DGST_SIZE_4_16;
8997 parse_func = whirlpool_parse_hash;
8998 sort_by_digest = sort_by_digest_4_16;
8999 opti_type = OPTI_TYPE_ZERO_BYTE;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9011 dgst_size = DGST_SIZE_4_5;
9012 parse_func = truecrypt_parse_hash_2k;
9013 sort_by_digest = sort_by_digest_4_5;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9025 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9026 dgst_size = DGST_SIZE_4_5;
9027 parse_func = truecrypt_parse_hash_2k;
9028 sort_by_digest = sort_by_digest_4_5;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9040 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9041 dgst_size = DGST_SIZE_4_5;
9042 parse_func = truecrypt_parse_hash_2k;
9043 sort_by_digest = sort_by_digest_4_5;
9044 opti_type = OPTI_TYPE_ZERO_BYTE;
9045 dgst_pos0 = 0;
9046 dgst_pos1 = 1;
9047 dgst_pos2 = 2;
9048 dgst_pos3 = 3;
9049 break;
9050
9051 case 6221: hash_type = HASH_TYPE_SHA512;
9052 salt_type = SALT_TYPE_EMBEDDED;
9053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9054 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9055 kern_type = KERN_TYPE_TCSHA512_XTS512;
9056 dgst_size = DGST_SIZE_8_8;
9057 parse_func = truecrypt_parse_hash_1k;
9058 sort_by_digest = sort_by_digest_8_8;
9059 opti_type = OPTI_TYPE_ZERO_BYTE
9060 | OPTI_TYPE_USES_BITS_64;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 6222: hash_type = HASH_TYPE_SHA512;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9072 dgst_size = DGST_SIZE_8_8;
9073 parse_func = truecrypt_parse_hash_1k;
9074 sort_by_digest = sort_by_digest_8_8;
9075 opti_type = OPTI_TYPE_ZERO_BYTE
9076 | OPTI_TYPE_USES_BITS_64;
9077 dgst_pos0 = 0;
9078 dgst_pos1 = 1;
9079 dgst_pos2 = 2;
9080 dgst_pos3 = 3;
9081 break;
9082
9083 case 6223: hash_type = HASH_TYPE_SHA512;
9084 salt_type = SALT_TYPE_EMBEDDED;
9085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9087 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9088 dgst_size = DGST_SIZE_8_8;
9089 parse_func = truecrypt_parse_hash_1k;
9090 sort_by_digest = sort_by_digest_8_8;
9091 opti_type = OPTI_TYPE_ZERO_BYTE
9092 | OPTI_TYPE_USES_BITS_64;
9093 dgst_pos0 = 0;
9094 dgst_pos1 = 1;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 3;
9097 break;
9098
9099 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9100 salt_type = SALT_TYPE_EMBEDDED;
9101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9103 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9104 dgst_size = DGST_SIZE_4_8;
9105 parse_func = truecrypt_parse_hash_1k;
9106 sort_by_digest = sort_by_digest_4_8;
9107 opti_type = OPTI_TYPE_ZERO_BYTE;
9108 dgst_pos0 = 0;
9109 dgst_pos1 = 1;
9110 dgst_pos2 = 2;
9111 dgst_pos3 = 3;
9112 break;
9113
9114 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9115 salt_type = SALT_TYPE_EMBEDDED;
9116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9117 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9118 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9119 dgst_size = DGST_SIZE_4_8;
9120 parse_func = truecrypt_parse_hash_1k;
9121 sort_by_digest = sort_by_digest_4_8;
9122 opti_type = OPTI_TYPE_ZERO_BYTE;
9123 dgst_pos0 = 0;
9124 dgst_pos1 = 1;
9125 dgst_pos2 = 2;
9126 dgst_pos3 = 3;
9127 break;
9128
9129 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9130 salt_type = SALT_TYPE_EMBEDDED;
9131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9133 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9134 dgst_size = DGST_SIZE_4_8;
9135 parse_func = truecrypt_parse_hash_1k;
9136 sort_by_digest = sort_by_digest_4_8;
9137 opti_type = OPTI_TYPE_ZERO_BYTE;
9138 dgst_pos0 = 0;
9139 dgst_pos1 = 1;
9140 dgst_pos2 = 2;
9141 dgst_pos3 = 3;
9142 break;
9143
9144 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9145 salt_type = SALT_TYPE_EMBEDDED;
9146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9147 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9148 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9149 dgst_size = DGST_SIZE_4_5;
9150 parse_func = truecrypt_parse_hash_1k;
9151 sort_by_digest = sort_by_digest_4_5;
9152 opti_type = OPTI_TYPE_ZERO_BYTE;
9153 dgst_pos0 = 0;
9154 dgst_pos1 = 1;
9155 dgst_pos2 = 2;
9156 dgst_pos3 = 3;
9157 break;
9158
9159 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9160 salt_type = SALT_TYPE_EMBEDDED;
9161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9162 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9163 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9164 dgst_size = DGST_SIZE_4_5;
9165 parse_func = truecrypt_parse_hash_1k;
9166 sort_by_digest = sort_by_digest_4_5;
9167 opti_type = OPTI_TYPE_ZERO_BYTE;
9168 dgst_pos0 = 0;
9169 dgst_pos1 = 1;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 3;
9172 break;
9173
9174 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9175 salt_type = SALT_TYPE_EMBEDDED;
9176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9178 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9179 dgst_size = DGST_SIZE_4_5;
9180 parse_func = truecrypt_parse_hash_1k;
9181 sort_by_digest = sort_by_digest_4_5;
9182 opti_type = OPTI_TYPE_ZERO_BYTE;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 6300: hash_type = HASH_TYPE_MD5;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9193 kern_type = KERN_TYPE_MD5AIX;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = md5aix_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_ZERO_BYTE;
9198 dgst_pos0 = 0;
9199 dgst_pos1 = 1;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 3;
9202 break;
9203
9204 case 6400: hash_type = HASH_TYPE_SHA256;
9205 salt_type = SALT_TYPE_EMBEDDED;
9206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9208 kern_type = KERN_TYPE_SHA256AIX;
9209 dgst_size = DGST_SIZE_4_8;
9210 parse_func = sha256aix_parse_hash;
9211 sort_by_digest = sort_by_digest_4_8;
9212 opti_type = OPTI_TYPE_ZERO_BYTE;
9213 dgst_pos0 = 0;
9214 dgst_pos1 = 1;
9215 dgst_pos2 = 2;
9216 dgst_pos3 = 3;
9217 break;
9218
9219 case 6500: hash_type = HASH_TYPE_SHA512;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9223 kern_type = KERN_TYPE_SHA512AIX;
9224 dgst_size = DGST_SIZE_8_8;
9225 parse_func = sha512aix_parse_hash;
9226 sort_by_digest = sort_by_digest_8_8;
9227 opti_type = OPTI_TYPE_ZERO_BYTE
9228 | OPTI_TYPE_USES_BITS_64;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 6600: hash_type = HASH_TYPE_AES;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9239 kern_type = KERN_TYPE_AGILEKEY;
9240 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9241 parse_func = agilekey_parse_hash;
9242 sort_by_digest = sort_by_digest_4_5;
9243 opti_type = OPTI_TYPE_ZERO_BYTE;
9244 dgst_pos0 = 0;
9245 dgst_pos1 = 1;
9246 dgst_pos2 = 2;
9247 dgst_pos3 = 3;
9248 break;
9249
9250 case 6700: hash_type = HASH_TYPE_SHA1;
9251 salt_type = SALT_TYPE_EMBEDDED;
9252 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9253 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9254 kern_type = KERN_TYPE_SHA1AIX;
9255 dgst_size = DGST_SIZE_4_5;
9256 parse_func = sha1aix_parse_hash;
9257 sort_by_digest = sort_by_digest_4_5;
9258 opti_type = OPTI_TYPE_ZERO_BYTE;
9259 dgst_pos0 = 0;
9260 dgst_pos1 = 1;
9261 dgst_pos2 = 2;
9262 dgst_pos3 = 3;
9263 break;
9264
9265 case 6800: hash_type = HASH_TYPE_AES;
9266 salt_type = SALT_TYPE_EMBEDDED;
9267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9268 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9269 kern_type = KERN_TYPE_LASTPASS;
9270 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9271 parse_func = lastpass_parse_hash;
9272 sort_by_digest = sort_by_digest_4_8;
9273 opti_type = OPTI_TYPE_ZERO_BYTE;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 6900: hash_type = HASH_TYPE_GOST;
9281 salt_type = SALT_TYPE_NONE;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9284 kern_type = KERN_TYPE_GOST;
9285 dgst_size = DGST_SIZE_4_8;
9286 parse_func = gost_parse_hash;
9287 sort_by_digest = sort_by_digest_4_8;
9288 opti_type = OPTI_TYPE_ZERO_BYTE;
9289 dgst_pos0 = 0;
9290 dgst_pos1 = 1;
9291 dgst_pos2 = 2;
9292 dgst_pos3 = 3;
9293 break;
9294
9295 case 7100: hash_type = HASH_TYPE_SHA512;
9296 salt_type = SALT_TYPE_EMBEDDED;
9297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9298 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9299 kern_type = KERN_TYPE_PBKDF2_SHA512;
9300 dgst_size = DGST_SIZE_8_16;
9301 parse_func = sha512osx_parse_hash;
9302 sort_by_digest = sort_by_digest_8_16;
9303 opti_type = OPTI_TYPE_ZERO_BYTE
9304 | OPTI_TYPE_USES_BITS_64
9305 | OPTI_TYPE_SLOW_HASH_SIMD;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 7200: hash_type = HASH_TYPE_SHA512;
9313 salt_type = SALT_TYPE_EMBEDDED;
9314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9316 kern_type = KERN_TYPE_PBKDF2_SHA512;
9317 dgst_size = DGST_SIZE_8_16;
9318 parse_func = sha512grub_parse_hash;
9319 sort_by_digest = sort_by_digest_8_16;
9320 opti_type = OPTI_TYPE_ZERO_BYTE
9321 | OPTI_TYPE_USES_BITS_64
9322 | OPTI_TYPE_SLOW_HASH_SIMD;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 7300: hash_type = HASH_TYPE_SHA1;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_BE
9333 | OPTS_TYPE_ST_ADD80
9334 | OPTS_TYPE_ST_ADDBITS15;
9335 kern_type = KERN_TYPE_RAKP;
9336 dgst_size = DGST_SIZE_4_5;
9337 parse_func = rakp_parse_hash;
9338 sort_by_digest = sort_by_digest_4_5;
9339 opti_type = OPTI_TYPE_ZERO_BYTE
9340 | OPTI_TYPE_NOT_ITERATED;
9341 dgst_pos0 = 3;
9342 dgst_pos1 = 4;
9343 dgst_pos2 = 2;
9344 dgst_pos3 = 1;
9345 break;
9346
9347 case 7400: hash_type = HASH_TYPE_SHA256;
9348 salt_type = SALT_TYPE_EMBEDDED;
9349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9350 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9351 kern_type = KERN_TYPE_SHA256CRYPT;
9352 dgst_size = DGST_SIZE_4_8;
9353 parse_func = sha256crypt_parse_hash;
9354 sort_by_digest = sort_by_digest_4_8;
9355 opti_type = OPTI_TYPE_ZERO_BYTE;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 7500: hash_type = HASH_TYPE_KRB5PA;
9363 salt_type = SALT_TYPE_EMBEDDED;
9364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_KRB5PA;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = krb5pa_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_ZERO_BYTE
9371 | OPTI_TYPE_NOT_ITERATED;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 7600: hash_type = HASH_TYPE_SHA1;
9379 salt_type = SALT_TYPE_INTERN;
9380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_BE
9382 | OPTS_TYPE_PT_ADD80
9383 | OPTS_TYPE_PT_ADDBITS15;
9384 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9385 dgst_size = DGST_SIZE_4_5;
9386 parse_func = redmine_parse_hash;
9387 sort_by_digest = sort_by_digest_4_5;
9388 opti_type = OPTI_TYPE_ZERO_BYTE
9389 | OPTI_TYPE_PRECOMPUTE_INIT
9390 | OPTI_TYPE_EARLY_SKIP
9391 | OPTI_TYPE_NOT_ITERATED
9392 | OPTI_TYPE_PREPENDED_SALT;
9393 dgst_pos0 = 3;
9394 dgst_pos1 = 4;
9395 dgst_pos2 = 2;
9396 dgst_pos3 = 1;
9397 break;
9398
9399 case 7700: hash_type = HASH_TYPE_SAPB;
9400 salt_type = SALT_TYPE_EMBEDDED;
9401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9402 opts_type = OPTS_TYPE_PT_GENERATE_LE
9403 | OPTS_TYPE_PT_UPPER
9404 | OPTS_TYPE_ST_UPPER;
9405 kern_type = KERN_TYPE_SAPB;
9406 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9407 parse_func = sapb_parse_hash;
9408 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9409 opti_type = OPTI_TYPE_ZERO_BYTE
9410 | OPTI_TYPE_PRECOMPUTE_INIT
9411 | OPTI_TYPE_NOT_ITERATED;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 7800: hash_type = HASH_TYPE_SAPG;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_BE
9422 | OPTS_TYPE_ST_ADD80
9423 | OPTS_TYPE_ST_UPPER;
9424 kern_type = KERN_TYPE_SAPG;
9425 dgst_size = DGST_SIZE_4_5;
9426 parse_func = sapg_parse_hash;
9427 sort_by_digest = sort_by_digest_4_5;
9428 opti_type = OPTI_TYPE_ZERO_BYTE
9429 | OPTI_TYPE_PRECOMPUTE_INIT
9430 | OPTI_TYPE_NOT_ITERATED;
9431 dgst_pos0 = 3;
9432 dgst_pos1 = 4;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 1;
9435 break;
9436
9437 case 7900: hash_type = HASH_TYPE_SHA512;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9441 kern_type = KERN_TYPE_DRUPAL7;
9442 dgst_size = DGST_SIZE_8_8;
9443 parse_func = drupal7_parse_hash;
9444 sort_by_digest = sort_by_digest_8_8;
9445 opti_type = OPTI_TYPE_ZERO_BYTE
9446 | OPTI_TYPE_USES_BITS_64;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 8000: hash_type = HASH_TYPE_SHA256;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_BE
9457 | OPTS_TYPE_PT_UNICODE
9458 | OPTS_TYPE_ST_ADD80
9459 | OPTS_TYPE_ST_HEX;
9460 kern_type = KERN_TYPE_SYBASEASE;
9461 dgst_size = DGST_SIZE_4_8;
9462 parse_func = sybasease_parse_hash;
9463 sort_by_digest = sort_by_digest_4_8;
9464 opti_type = OPTI_TYPE_ZERO_BYTE
9465 | OPTI_TYPE_PRECOMPUTE_INIT
9466 | OPTI_TYPE_EARLY_SKIP
9467 | OPTI_TYPE_NOT_ITERATED
9468 | OPTI_TYPE_RAW_HASH;
9469 dgst_pos0 = 3;
9470 dgst_pos1 = 7;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 6;
9473 break;
9474
9475 case 8100: hash_type = HASH_TYPE_SHA1;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9479 kern_type = KERN_TYPE_NETSCALER;
9480 dgst_size = DGST_SIZE_4_5;
9481 parse_func = netscaler_parse_hash;
9482 sort_by_digest = sort_by_digest_4_5;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_PRECOMPUTE_INIT
9485 | OPTI_TYPE_PRECOMPUTE_MERKLE
9486 | OPTI_TYPE_EARLY_SKIP
9487 | OPTI_TYPE_NOT_ITERATED
9488 | OPTI_TYPE_PREPENDED_SALT
9489 | OPTI_TYPE_RAW_HASH;
9490 dgst_pos0 = 3;
9491 dgst_pos1 = 4;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 1;
9494 break;
9495
9496 case 8200: hash_type = HASH_TYPE_SHA256;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9500 kern_type = KERN_TYPE_CLOUDKEY;
9501 dgst_size = DGST_SIZE_4_8;
9502 parse_func = cloudkey_parse_hash;
9503 sort_by_digest = sort_by_digest_4_8;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 8300: hash_type = HASH_TYPE_SHA1;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_BE
9515 | OPTS_TYPE_ST_HEX
9516 | OPTS_TYPE_ST_ADD80;
9517 kern_type = KERN_TYPE_NSEC3;
9518 dgst_size = DGST_SIZE_4_5;
9519 parse_func = nsec3_parse_hash;
9520 sort_by_digest = sort_by_digest_4_5;
9521 opti_type = OPTI_TYPE_ZERO_BYTE;
9522 dgst_pos0 = 3;
9523 dgst_pos1 = 4;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 1;
9526 break;
9527
9528 case 8400: hash_type = HASH_TYPE_SHA1;
9529 salt_type = SALT_TYPE_INTERN;
9530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_BE
9532 | OPTS_TYPE_PT_ADD80
9533 | OPTS_TYPE_PT_ADDBITS15;
9534 kern_type = KERN_TYPE_WBB3;
9535 dgst_size = DGST_SIZE_4_5;
9536 parse_func = wbb3_parse_hash;
9537 sort_by_digest = sort_by_digest_4_5;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_PRECOMPUTE_INIT
9540 | OPTI_TYPE_NOT_ITERATED;
9541 dgst_pos0 = 3;
9542 dgst_pos1 = 4;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 1;
9545 break;
9546
9547 case 8500: hash_type = HASH_TYPE_DESRACF;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE
9551 | OPTS_TYPE_ST_UPPER;
9552 kern_type = KERN_TYPE_RACF;
9553 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9554 parse_func = racf_parse_hash;
9555 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9556 opti_type = OPTI_TYPE_ZERO_BYTE
9557 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 8600: hash_type = HASH_TYPE_LOTUS5;
9565 salt_type = SALT_TYPE_NONE;
9566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9568 kern_type = KERN_TYPE_LOTUS5;
9569 dgst_size = DGST_SIZE_4_4;
9570 parse_func = lotus5_parse_hash;
9571 sort_by_digest = sort_by_digest_4_4;
9572 opti_type = OPTI_TYPE_EARLY_SKIP
9573 | OPTI_TYPE_NOT_ITERATED
9574 | OPTI_TYPE_NOT_SALTED
9575 | OPTI_TYPE_RAW_HASH;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 8700: hash_type = HASH_TYPE_LOTUS6;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_LOTUS6;
9587 dgst_size = DGST_SIZE_4_4;
9588 parse_func = lotus6_parse_hash;
9589 sort_by_digest = sort_by_digest_4_4;
9590 opti_type = OPTI_TYPE_EARLY_SKIP
9591 | OPTI_TYPE_NOT_ITERATED
9592 | OPTI_TYPE_RAW_HASH;
9593 dgst_pos0 = 0;
9594 dgst_pos1 = 1;
9595 dgst_pos2 = 2;
9596 dgst_pos3 = 3;
9597 break;
9598
9599 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9600 salt_type = SALT_TYPE_EMBEDDED;
9601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9603 kern_type = KERN_TYPE_ANDROIDFDE;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = androidfde_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE;
9608 dgst_pos0 = 0;
9609 dgst_pos1 = 1;
9610 dgst_pos2 = 2;
9611 dgst_pos3 = 3;
9612 break;
9613
9614 case 8900: hash_type = HASH_TYPE_SCRYPT;
9615 salt_type = SALT_TYPE_EMBEDDED;
9616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9617 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9618 kern_type = KERN_TYPE_SCRYPT;
9619 dgst_size = DGST_SIZE_4_8;
9620 parse_func = scrypt_parse_hash;
9621 sort_by_digest = sort_by_digest_4_8;
9622 opti_type = OPTI_TYPE_ZERO_BYTE;
9623 dgst_pos0 = 0;
9624 dgst_pos1 = 1;
9625 dgst_pos2 = 2;
9626 dgst_pos3 = 3;
9627 break;
9628
9629 case 9000: hash_type = HASH_TYPE_SHA1;
9630 salt_type = SALT_TYPE_EMBEDDED;
9631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9632 opts_type = OPTS_TYPE_PT_GENERATE_LE
9633 | OPTS_TYPE_ST_GENERATE_LE;
9634 kern_type = KERN_TYPE_PSAFE2;
9635 dgst_size = DGST_SIZE_4_5;
9636 parse_func = psafe2_parse_hash;
9637 sort_by_digest = sort_by_digest_4_5;
9638 opti_type = OPTI_TYPE_ZERO_BYTE;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 9100: hash_type = HASH_TYPE_LOTUS8;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9649 kern_type = KERN_TYPE_LOTUS8;
9650 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9651 parse_func = lotus8_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9653 opti_type = OPTI_TYPE_ZERO_BYTE;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 9200: hash_type = HASH_TYPE_SHA256;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9664 kern_type = KERN_TYPE_PBKDF2_SHA256;
9665 dgst_size = DGST_SIZE_4_32;
9666 parse_func = cisco8_parse_hash;
9667 sort_by_digest = sort_by_digest_4_32;
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_SLOW_HASH_SIMD;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 9300: hash_type = HASH_TYPE_SCRYPT;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_SCRYPT;
9681 dgst_size = DGST_SIZE_4_8;
9682 parse_func = cisco9_parse_hash;
9683 sort_by_digest = sort_by_digest_4_8;
9684 opti_type = OPTI_TYPE_ZERO_BYTE;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 1;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 3;
9689 break;
9690
9691 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9695 kern_type = KERN_TYPE_OFFICE2007;
9696 dgst_size = DGST_SIZE_4_4;
9697 parse_func = office2007_parse_hash;
9698 sort_by_digest = sort_by_digest_4_4;
9699 opti_type = OPTI_TYPE_ZERO_BYTE;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9710 kern_type = KERN_TYPE_OFFICE2010;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = office2010_parse_hash;
9713 sort_by_digest = sort_by_digest_4_4;
9714 opti_type = OPTI_TYPE_ZERO_BYTE;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 1;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 3;
9719 break;
9720
9721 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9725 kern_type = KERN_TYPE_OFFICE2013;
9726 dgst_size = DGST_SIZE_4_4;
9727 parse_func = office2013_parse_hash;
9728 sort_by_digest = sort_by_digest_4_4;
9729 opti_type = OPTI_TYPE_ZERO_BYTE;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE
9740 | OPTS_TYPE_PT_ADD80
9741 | OPTS_TYPE_PT_UNICODE;
9742 kern_type = KERN_TYPE_OLDOFFICE01;
9743 dgst_size = DGST_SIZE_4_4;
9744 parse_func = oldoffice01_parse_hash;
9745 sort_by_digest = sort_by_digest_4_4;
9746 opti_type = OPTI_TYPE_ZERO_BYTE
9747 | OPTI_TYPE_PRECOMPUTE_INIT
9748 | OPTI_TYPE_NOT_ITERATED;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9756 salt_type = SALT_TYPE_EMBEDDED;
9757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9758 opts_type = OPTS_TYPE_PT_GENERATE_LE
9759 | OPTS_TYPE_PT_ADD80;
9760 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = oldoffice01cm1_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_PRECOMPUTE_INIT
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE
9777 | OPTS_TYPE_PT_ADD80
9778 | OPTS_TYPE_PT_UNICODE
9779 | OPTS_TYPE_PT_NEVERCRACK;
9780 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9781 dgst_size = DGST_SIZE_4_4;
9782 parse_func = oldoffice01cm2_parse_hash;
9783 sort_by_digest = sort_by_digest_4_4;
9784 opti_type = OPTI_TYPE_ZERO_BYTE
9785 | OPTI_TYPE_PRECOMPUTE_INIT
9786 | OPTI_TYPE_NOT_ITERATED;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_BE
9797 | OPTS_TYPE_PT_ADD80
9798 | OPTS_TYPE_PT_UNICODE;
9799 kern_type = KERN_TYPE_OLDOFFICE34;
9800 dgst_size = DGST_SIZE_4_4;
9801 parse_func = oldoffice34_parse_hash;
9802 sort_by_digest = sort_by_digest_4_4;
9803 opti_type = OPTI_TYPE_ZERO_BYTE
9804 | OPTI_TYPE_PRECOMPUTE_INIT
9805 | OPTI_TYPE_NOT_ITERATED;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9813 salt_type = SALT_TYPE_EMBEDDED;
9814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9816 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9817 dgst_size = DGST_SIZE_4_4;
9818 parse_func = oldoffice34cm1_parse_hash;
9819 sort_by_digest = sort_by_digest_4_4;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_PRECOMPUTE_INIT
9822 | OPTI_TYPE_NOT_ITERATED;
9823 dgst_pos0 = 0;
9824 dgst_pos1 = 1;
9825 dgst_pos2 = 2;
9826 dgst_pos3 = 3;
9827 break;
9828
9829 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9830 salt_type = SALT_TYPE_EMBEDDED;
9831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9832 opts_type = OPTS_TYPE_PT_GENERATE_BE
9833 | OPTS_TYPE_PT_ADD80
9834 | OPTS_TYPE_PT_UNICODE
9835 | OPTS_TYPE_PT_NEVERCRACK;
9836 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9837 dgst_size = DGST_SIZE_4_4;
9838 parse_func = oldoffice34cm2_parse_hash;
9839 sort_by_digest = sort_by_digest_4_4;
9840 opti_type = OPTI_TYPE_ZERO_BYTE
9841 | OPTI_TYPE_PRECOMPUTE_INIT
9842 | OPTI_TYPE_NOT_ITERATED;
9843 dgst_pos0 = 0;
9844 dgst_pos1 = 1;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 3;
9847 break;
9848
9849 case 9900: hash_type = HASH_TYPE_MD5;
9850 salt_type = SALT_TYPE_NONE;
9851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9853 kern_type = KERN_TYPE_RADMIN2;
9854 dgst_size = DGST_SIZE_4_4;
9855 parse_func = radmin2_parse_hash;
9856 sort_by_digest = sort_by_digest_4_4;
9857 opti_type = OPTI_TYPE_ZERO_BYTE
9858 | OPTI_TYPE_PRECOMPUTE_INIT
9859 | OPTI_TYPE_EARLY_SKIP
9860 | OPTI_TYPE_NOT_ITERATED
9861 | OPTI_TYPE_NOT_SALTED;
9862 dgst_pos0 = 0;
9863 dgst_pos1 = 3;
9864 dgst_pos2 = 2;
9865 dgst_pos3 = 1;
9866 break;
9867
9868 case 10000: hash_type = HASH_TYPE_SHA256;
9869 salt_type = SALT_TYPE_EMBEDDED;
9870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9871 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9872 kern_type = KERN_TYPE_PBKDF2_SHA256;
9873 dgst_size = DGST_SIZE_4_32;
9874 parse_func = djangopbkdf2_parse_hash;
9875 sort_by_digest = sort_by_digest_4_32;
9876 opti_type = OPTI_TYPE_ZERO_BYTE
9877 | OPTI_TYPE_SLOW_HASH_SIMD;
9878 dgst_pos0 = 0;
9879 dgst_pos1 = 1;
9880 dgst_pos2 = 2;
9881 dgst_pos3 = 3;
9882 break;
9883
9884 case 10100: hash_type = HASH_TYPE_SIPHASH;
9885 salt_type = SALT_TYPE_EMBEDDED;
9886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9888 kern_type = KERN_TYPE_SIPHASH;
9889 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9890 parse_func = siphash_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_NOT_ITERATED
9894 | OPTI_TYPE_RAW_HASH;
9895 dgst_pos0 = 0;
9896 dgst_pos1 = 1;
9897 dgst_pos2 = 2;
9898 dgst_pos3 = 3;
9899 break;
9900
9901 case 10200: hash_type = HASH_TYPE_MD5;
9902 salt_type = SALT_TYPE_EMBEDDED;
9903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_ST_ADD80
9906 | OPTS_TYPE_ST_ADDBITS14;
9907 kern_type = KERN_TYPE_HMACMD5_PW;
9908 dgst_size = DGST_SIZE_4_4;
9909 parse_func = crammd5_parse_hash;
9910 sort_by_digest = sort_by_digest_4_4;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_NOT_ITERATED;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 3;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 1;
9917 break;
9918
9919 case 10300: hash_type = HASH_TYPE_SHA1;
9920 salt_type = SALT_TYPE_EMBEDDED;
9921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9923 kern_type = KERN_TYPE_SAPH_SHA1;
9924 dgst_size = DGST_SIZE_4_5;
9925 parse_func = saph_sha1_parse_hash;
9926 sort_by_digest = sort_by_digest_4_5;
9927 opti_type = OPTI_TYPE_ZERO_BYTE;
9928 dgst_pos0 = 0;
9929 dgst_pos1 = 1;
9930 dgst_pos2 = 2;
9931 dgst_pos3 = 3;
9932 break;
9933
9934 case 10400: hash_type = HASH_TYPE_PDFU16;
9935 salt_type = SALT_TYPE_EMBEDDED;
9936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9938 kern_type = KERN_TYPE_PDF11;
9939 dgst_size = DGST_SIZE_4_4;
9940 parse_func = pdf11_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4;
9942 opti_type = OPTI_TYPE_ZERO_BYTE
9943 | OPTI_TYPE_NOT_ITERATED;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 10410: hash_type = HASH_TYPE_PDFU16;
9951 salt_type = SALT_TYPE_EMBEDDED;
9952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9954 kern_type = KERN_TYPE_PDF11CM1;
9955 dgst_size = DGST_SIZE_4_4;
9956 parse_func = pdf11cm1_parse_hash;
9957 sort_by_digest = sort_by_digest_4_4;
9958 opti_type = OPTI_TYPE_ZERO_BYTE
9959 | OPTI_TYPE_NOT_ITERATED;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 10420: hash_type = HASH_TYPE_PDFU16;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9970 kern_type = KERN_TYPE_PDF11CM2;
9971 dgst_size = DGST_SIZE_4_4;
9972 parse_func = pdf11cm2_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4;
9974 opti_type = OPTI_TYPE_ZERO_BYTE
9975 | OPTI_TYPE_NOT_ITERATED;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 10500: hash_type = HASH_TYPE_PDFU16;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_PDF14;
9987 dgst_size = DGST_SIZE_4_4;
9988 parse_func = pdf14_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_NOT_ITERATED;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 10600: hash_type = HASH_TYPE_SHA256;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_BE
10002 | OPTS_TYPE_ST_ADD80
10003 | OPTS_TYPE_ST_ADDBITS15
10004 | OPTS_TYPE_HASH_COPY;
10005 kern_type = KERN_TYPE_SHA256_PWSLT;
10006 dgst_size = DGST_SIZE_4_8;
10007 parse_func = pdf17l3_parse_hash;
10008 sort_by_digest = sort_by_digest_4_8;
10009 opti_type = OPTI_TYPE_ZERO_BYTE
10010 | OPTI_TYPE_PRECOMPUTE_INIT
10011 | OPTI_TYPE_PRECOMPUTE_MERKLE
10012 | OPTI_TYPE_EARLY_SKIP
10013 | OPTI_TYPE_NOT_ITERATED
10014 | OPTI_TYPE_APPENDED_SALT
10015 | OPTI_TYPE_RAW_HASH;
10016 dgst_pos0 = 3;
10017 dgst_pos1 = 7;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 6;
10020 break;
10021
10022 case 10700: hash_type = HASH_TYPE_PDFU32;
10023 salt_type = SALT_TYPE_EMBEDDED;
10024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_HASH_COPY;
10027 kern_type = KERN_TYPE_PDF17L8;
10028 dgst_size = DGST_SIZE_4_8;
10029 parse_func = pdf17l8_parse_hash;
10030 sort_by_digest = sort_by_digest_4_8;
10031 opti_type = OPTI_TYPE_ZERO_BYTE
10032 | OPTI_TYPE_NOT_ITERATED;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 10800: hash_type = HASH_TYPE_SHA384;
10040 salt_type = SALT_TYPE_NONE;
10041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_BE
10043 | OPTS_TYPE_PT_ADD80
10044 | OPTS_TYPE_PT_ADDBITS15;
10045 kern_type = KERN_TYPE_SHA384;
10046 dgst_size = DGST_SIZE_8_8;
10047 parse_func = sha384_parse_hash;
10048 sort_by_digest = sort_by_digest_8_8;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_PRECOMPUTE_INIT
10051 | OPTI_TYPE_PRECOMPUTE_MERKLE
10052 | OPTI_TYPE_EARLY_SKIP
10053 | OPTI_TYPE_NOT_ITERATED
10054 | OPTI_TYPE_NOT_SALTED
10055 | OPTI_TYPE_USES_BITS_64
10056 | OPTI_TYPE_RAW_HASH;
10057 dgst_pos0 = 6;
10058 dgst_pos1 = 7;
10059 dgst_pos2 = 4;
10060 dgst_pos3 = 5;
10061 break;
10062
10063 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE
10067 | OPTS_TYPE_ST_BASE64
10068 | OPTS_TYPE_HASH_COPY;
10069 kern_type = KERN_TYPE_PBKDF2_SHA256;
10070 dgst_size = DGST_SIZE_4_32;
10071 parse_func = pbkdf2_sha256_parse_hash;
10072 sort_by_digest = sort_by_digest_4_32;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_SLOW_HASH_SIMD;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 11000: hash_type = HASH_TYPE_MD5;
10082 salt_type = SALT_TYPE_INTERN;
10083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE
10085 | OPTS_TYPE_PT_ADD80;
10086 kern_type = KERN_TYPE_PRESTASHOP;
10087 dgst_size = DGST_SIZE_4_4;
10088 parse_func = prestashop_parse_hash;
10089 sort_by_digest = sort_by_digest_4_4;
10090 opti_type = OPTI_TYPE_ZERO_BYTE
10091 | OPTI_TYPE_PRECOMPUTE_INIT
10092 | OPTI_TYPE_NOT_ITERATED
10093 | OPTI_TYPE_PREPENDED_SALT;
10094 dgst_pos0 = 0;
10095 dgst_pos1 = 3;
10096 dgst_pos2 = 2;
10097 dgst_pos3 = 1;
10098 break;
10099
10100 case 11100: hash_type = HASH_TYPE_MD5;
10101 salt_type = SALT_TYPE_EMBEDDED;
10102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10103 opts_type = OPTS_TYPE_PT_GENERATE_LE
10104 | OPTS_TYPE_ST_ADD80;
10105 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10106 dgst_size = DGST_SIZE_4_4;
10107 parse_func = postgresql_auth_parse_hash;
10108 sort_by_digest = sort_by_digest_4_4;
10109 opti_type = OPTI_TYPE_ZERO_BYTE
10110 | OPTI_TYPE_PRECOMPUTE_INIT
10111 | OPTI_TYPE_PRECOMPUTE_MERKLE
10112 | OPTI_TYPE_EARLY_SKIP;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 3;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 1;
10117 break;
10118
10119 case 11200: hash_type = HASH_TYPE_SHA1;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_BE
10123 | OPTS_TYPE_PT_ADD80
10124 | OPTS_TYPE_ST_HEX;
10125 kern_type = KERN_TYPE_MYSQL_AUTH;
10126 dgst_size = DGST_SIZE_4_5;
10127 parse_func = mysql_auth_parse_hash;
10128 sort_by_digest = sort_by_digest_4_5;
10129 opti_type = OPTI_TYPE_ZERO_BYTE
10130 | OPTI_TYPE_EARLY_SKIP;
10131 dgst_pos0 = 3;
10132 dgst_pos1 = 4;
10133 dgst_pos2 = 2;
10134 dgst_pos3 = 1;
10135 break;
10136
10137 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10138 salt_type = SALT_TYPE_EMBEDDED;
10139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10140 opts_type = OPTS_TYPE_PT_GENERATE_LE
10141 | OPTS_TYPE_ST_HEX
10142 | OPTS_TYPE_ST_ADD80;
10143 kern_type = KERN_TYPE_BITCOIN_WALLET;
10144 dgst_size = DGST_SIZE_4_4;
10145 parse_func = bitcoin_wallet_parse_hash;
10146 sort_by_digest = sort_by_digest_4_4;
10147 opti_type = OPTI_TYPE_ZERO_BYTE;
10148 dgst_pos0 = 0;
10149 dgst_pos1 = 1;
10150 dgst_pos2 = 2;
10151 dgst_pos3 = 3;
10152 break;
10153
10154 case 11400: hash_type = HASH_TYPE_MD5;
10155 salt_type = SALT_TYPE_EMBEDDED;
10156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10157 opts_type = OPTS_TYPE_PT_GENERATE_LE
10158 | OPTS_TYPE_PT_ADD80
10159 | OPTS_TYPE_HASH_COPY;
10160 kern_type = KERN_TYPE_SIP_AUTH;
10161 dgst_size = DGST_SIZE_4_4;
10162 parse_func = sip_auth_parse_hash;
10163 sort_by_digest = sort_by_digest_4_4;
10164 opti_type = OPTI_TYPE_ZERO_BYTE;
10165 dgst_pos0 = 0;
10166 dgst_pos1 = 3;
10167 dgst_pos2 = 2;
10168 dgst_pos3 = 1;
10169 break;
10170
10171 case 11500: hash_type = HASH_TYPE_CRC32;
10172 salt_type = SALT_TYPE_INTERN;
10173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10174 opts_type = OPTS_TYPE_PT_GENERATE_LE
10175 | OPTS_TYPE_ST_GENERATE_LE
10176 | OPTS_TYPE_ST_HEX;
10177 kern_type = KERN_TYPE_CRC32;
10178 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10179 parse_func = crc32_parse_hash;
10180 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 11600: hash_type = HASH_TYPE_AES;
10189 salt_type = SALT_TYPE_EMBEDDED;
10190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_LE
10192 | OPTS_TYPE_PT_NEVERCRACK;
10193 kern_type = KERN_TYPE_SEVEN_ZIP;
10194 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10195 parse_func = seven_zip_parse_hash;
10196 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10197 opti_type = OPTI_TYPE_ZERO_BYTE;
10198 dgst_pos0 = 0;
10199 dgst_pos1 = 1;
10200 dgst_pos2 = 2;
10201 dgst_pos3 = 3;
10202 break;
10203
10204 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10205 salt_type = SALT_TYPE_NONE;
10206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10207 opts_type = OPTS_TYPE_PT_GENERATE_LE
10208 | OPTS_TYPE_PT_ADD01;
10209 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10210 dgst_size = DGST_SIZE_4_8;
10211 parse_func = gost2012sbog_256_parse_hash;
10212 sort_by_digest = sort_by_digest_4_8;
10213 opti_type = OPTI_TYPE_ZERO_BYTE;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10221 salt_type = SALT_TYPE_NONE;
10222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_LE
10224 | OPTS_TYPE_PT_ADD01;
10225 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10226 dgst_size = DGST_SIZE_4_16;
10227 parse_func = gost2012sbog_512_parse_hash;
10228 sort_by_digest = sort_by_digest_4_16;
10229 opti_type = OPTI_TYPE_ZERO_BYTE;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 1;
10232 dgst_pos2 = 2;
10233 dgst_pos3 = 3;
10234 break;
10235
10236 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10237 salt_type = SALT_TYPE_EMBEDDED;
10238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE
10240 | OPTS_TYPE_ST_BASE64
10241 | OPTS_TYPE_HASH_COPY;
10242 kern_type = KERN_TYPE_PBKDF2_MD5;
10243 dgst_size = DGST_SIZE_4_32;
10244 parse_func = pbkdf2_md5_parse_hash;
10245 sort_by_digest = sort_by_digest_4_32;
10246 opti_type = OPTI_TYPE_ZERO_BYTE
10247 | OPTI_TYPE_SLOW_HASH_SIMD;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10255 salt_type = SALT_TYPE_EMBEDDED;
10256 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_LE
10258 | OPTS_TYPE_ST_BASE64
10259 | OPTS_TYPE_HASH_COPY;
10260 kern_type = KERN_TYPE_PBKDF2_SHA1;
10261 dgst_size = DGST_SIZE_4_32;
10262 parse_func = pbkdf2_sha1_parse_hash;
10263 sort_by_digest = sort_by_digest_4_32;
10264 opti_type = OPTI_TYPE_ZERO_BYTE
10265 | OPTI_TYPE_SLOW_HASH_SIMD;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 1;
10268 dgst_pos2 = 2;
10269 dgst_pos3 = 3;
10270 break;
10271
10272 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_LE
10276 | OPTS_TYPE_ST_BASE64
10277 | OPTS_TYPE_HASH_COPY;
10278 kern_type = KERN_TYPE_PBKDF2_SHA512;
10279 dgst_size = DGST_SIZE_8_16;
10280 parse_func = pbkdf2_sha512_parse_hash;
10281 sort_by_digest = sort_by_digest_8_16;
10282 opti_type = OPTI_TYPE_ZERO_BYTE
10283 | OPTI_TYPE_USES_BITS_64
10284 | OPTI_TYPE_SLOW_HASH_SIMD;
10285 dgst_pos0 = 0;
10286 dgst_pos1 = 1;
10287 dgst_pos2 = 2;
10288 dgst_pos3 = 3;
10289 break;
10290
10291 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10292 salt_type = SALT_TYPE_EMBEDDED;
10293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10295 kern_type = KERN_TYPE_ECRYPTFS;
10296 dgst_size = DGST_SIZE_8_8;
10297 parse_func = ecryptfs_parse_hash;
10298 sort_by_digest = sort_by_digest_8_8;
10299 opti_type = OPTI_TYPE_ZERO_BYTE
10300 | OPTI_TYPE_USES_BITS_64;
10301 dgst_pos0 = 0;
10302 dgst_pos1 = 1;
10303 dgst_pos2 = 2;
10304 dgst_pos3 = 3;
10305 break;
10306
10307 case 12300: hash_type = HASH_TYPE_ORACLET;
10308 salt_type = SALT_TYPE_EMBEDDED;
10309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10310 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10311 kern_type = KERN_TYPE_ORACLET;
10312 dgst_size = DGST_SIZE_8_16;
10313 parse_func = oraclet_parse_hash;
10314 sort_by_digest = sort_by_digest_8_16;
10315 opti_type = OPTI_TYPE_ZERO_BYTE
10316 | OPTI_TYPE_USES_BITS_64;
10317 dgst_pos0 = 0;
10318 dgst_pos1 = 1;
10319 dgst_pos2 = 2;
10320 dgst_pos3 = 3;
10321 break;
10322
10323 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10324 salt_type = SALT_TYPE_EMBEDDED;
10325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10326 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10327 kern_type = KERN_TYPE_BSDICRYPT;
10328 dgst_size = DGST_SIZE_4_4;
10329 parse_func = bsdicrypt_parse_hash;
10330 sort_by_digest = sort_by_digest_4_4;
10331 opti_type = OPTI_TYPE_ZERO_BYTE
10332 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 12500: hash_type = HASH_TYPE_RAR3HP;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10343 kern_type = KERN_TYPE_RAR3;
10344 dgst_size = DGST_SIZE_4_4;
10345 parse_func = rar3hp_parse_hash;
10346 sort_by_digest = sort_by_digest_4_4;
10347 opti_type = OPTI_TYPE_ZERO_BYTE;
10348 dgst_pos0 = 0;
10349 dgst_pos1 = 1;
10350 dgst_pos2 = 2;
10351 dgst_pos3 = 3;
10352 break;
10353
10354 case 12600: hash_type = HASH_TYPE_SHA256;
10355 salt_type = SALT_TYPE_INTERN;
10356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10357 opts_type = OPTS_TYPE_PT_GENERATE_BE
10358 | OPTS_TYPE_PT_ADD80;
10359 kern_type = KERN_TYPE_CF10;
10360 dgst_size = DGST_SIZE_4_8;
10361 parse_func = cf10_parse_hash;
10362 sort_by_digest = sort_by_digest_4_8;
10363 opti_type = OPTI_TYPE_ZERO_BYTE
10364 | OPTI_TYPE_PRECOMPUTE_INIT
10365 | OPTI_TYPE_EARLY_SKIP
10366 | OPTI_TYPE_NOT_ITERATED;
10367 dgst_pos0 = 3;
10368 dgst_pos1 = 7;
10369 dgst_pos2 = 2;
10370 dgst_pos3 = 6;
10371 break;
10372
10373 case 12700: hash_type = HASH_TYPE_AES;
10374 salt_type = SALT_TYPE_EMBEDDED;
10375 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10376 opts_type = OPTS_TYPE_PT_GENERATE_LE
10377 | OPTS_TYPE_HASH_COPY;
10378 kern_type = KERN_TYPE_MYWALLET;
10379 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10380 parse_func = mywallet_parse_hash;
10381 sort_by_digest = sort_by_digest_4_5;
10382 opti_type = OPTI_TYPE_ZERO_BYTE;
10383 dgst_pos0 = 0;
10384 dgst_pos1 = 1;
10385 dgst_pos2 = 2;
10386 dgst_pos3 = 3;
10387 break;
10388
10389 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10390 salt_type = SALT_TYPE_EMBEDDED;
10391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10393 kern_type = KERN_TYPE_MS_DRSR;
10394 dgst_size = DGST_SIZE_4_8;
10395 parse_func = ms_drsr_parse_hash;
10396 sort_by_digest = sort_by_digest_4_8;
10397 opti_type = OPTI_TYPE_ZERO_BYTE;
10398 dgst_pos0 = 0;
10399 dgst_pos1 = 1;
10400 dgst_pos2 = 2;
10401 dgst_pos3 = 3;
10402 break;
10403
10404 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10405 salt_type = SALT_TYPE_EMBEDDED;
10406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10408 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10409 dgst_size = DGST_SIZE_4_8;
10410 parse_func = androidfde_samsung_parse_hash;
10411 sort_by_digest = sort_by_digest_4_8;
10412 opti_type = OPTI_TYPE_ZERO_BYTE;
10413 dgst_pos0 = 0;
10414 dgst_pos1 = 1;
10415 dgst_pos2 = 2;
10416 dgst_pos3 = 3;
10417 break;
10418
10419 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10420 salt_type = SALT_TYPE_EMBEDDED;
10421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10423 kern_type = KERN_TYPE_RAR5;
10424 dgst_size = DGST_SIZE_4_4;
10425 parse_func = rar5_parse_hash;
10426 sort_by_digest = sort_by_digest_4_4;
10427 opti_type = OPTI_TYPE_ZERO_BYTE;
10428 dgst_pos0 = 0;
10429 dgst_pos1 = 1;
10430 dgst_pos2 = 2;
10431 dgst_pos3 = 3;
10432 break;
10433
10434 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10435 salt_type = SALT_TYPE_EMBEDDED;
10436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10438 kern_type = KERN_TYPE_KRB5TGS;
10439 dgst_size = DGST_SIZE_4_4;
10440 parse_func = krb5tgs_parse_hash;
10441 sort_by_digest = sort_by_digest_4_4;
10442 opti_type = OPTI_TYPE_ZERO_BYTE
10443 | OPTI_TYPE_NOT_ITERATED;
10444 dgst_pos0 = 0;
10445 dgst_pos1 = 1;
10446 dgst_pos2 = 2;
10447 dgst_pos3 = 3;
10448 break;
10449
10450 case 13200: hash_type = HASH_TYPE_AES;
10451 salt_type = SALT_TYPE_EMBEDDED;
10452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10454 kern_type = KERN_TYPE_AXCRYPT;
10455 dgst_size = DGST_SIZE_4_4;
10456 parse_func = axcrypt_parse_hash;
10457 sort_by_digest = sort_by_digest_4_4;
10458 opti_type = OPTI_TYPE_ZERO_BYTE;
10459 dgst_pos0 = 0;
10460 dgst_pos1 = 1;
10461 dgst_pos2 = 2;
10462 dgst_pos3 = 3;
10463 break;
10464
10465 case 13300: hash_type = HASH_TYPE_SHA1;
10466 salt_type = SALT_TYPE_NONE;
10467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10468 opts_type = OPTS_TYPE_PT_GENERATE_BE
10469 | OPTS_TYPE_PT_ADD80
10470 | OPTS_TYPE_PT_ADDBITS15;
10471 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10472 dgst_size = DGST_SIZE_4_5;
10473 parse_func = sha1axcrypt_parse_hash;
10474 sort_by_digest = sort_by_digest_4_5;
10475 opti_type = OPTI_TYPE_ZERO_BYTE
10476 | OPTI_TYPE_PRECOMPUTE_INIT
10477 | OPTI_TYPE_EARLY_SKIP
10478 | OPTI_TYPE_NOT_ITERATED
10479 | OPTI_TYPE_NOT_SALTED;
10480 dgst_pos0 = 0;
10481 dgst_pos1 = 4;
10482 dgst_pos2 = 3;
10483 dgst_pos3 = 2;
10484 break;
10485
10486 case 13400: hash_type = HASH_TYPE_AES;
10487 salt_type = SALT_TYPE_EMBEDDED;
10488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10490 kern_type = KERN_TYPE_KEEPASS;
10491 dgst_size = DGST_SIZE_4_4;
10492 parse_func = keepass_parse_hash;
10493 sort_by_digest = sort_by_digest_4_4;
10494 opti_type = OPTI_TYPE_ZERO_BYTE;
10495 dgst_pos0 = 0;
10496 dgst_pos1 = 1;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 3;
10499 break;
10500
10501 case 13500: hash_type = HASH_TYPE_SHA1;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_BE
10505 | OPTS_TYPE_PT_UNICODE
10506 | OPTS_TYPE_PT_ADD80;
10507 kern_type = KERN_TYPE_PSTOKEN;
10508 dgst_size = DGST_SIZE_4_5;
10509 parse_func = pstoken_parse_hash;
10510 sort_by_digest = sort_by_digest_4_5;
10511 opti_type = OPTI_TYPE_ZERO_BYTE
10512 | OPTI_TYPE_PRECOMPUTE_INIT
10513 | OPTI_TYPE_EARLY_SKIP
10514 | OPTI_TYPE_NOT_ITERATED
10515 | OPTI_TYPE_PREPENDED_SALT
10516 | OPTI_TYPE_RAW_HASH;
10517 dgst_pos0 = 3;
10518 dgst_pos1 = 4;
10519 dgst_pos2 = 2;
10520 dgst_pos3 = 1;
10521 break;
10522
10523 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10524 salt_type = SALT_TYPE_EMBEDDED;
10525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10527 kern_type = KERN_TYPE_ZIP2;
10528 dgst_size = DGST_SIZE_4_4;
10529 parse_func = zip2_parse_hash;
10530 sort_by_digest = sort_by_digest_4_4;
10531 opti_type = OPTI_TYPE_ZERO_BYTE;
10532 dgst_pos0 = 0;
10533 dgst_pos1 = 1;
10534 dgst_pos2 = 2;
10535 dgst_pos3 = 3;
10536 break;
10537
10538 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10539 salt_type = SALT_TYPE_EMBEDDED;
10540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10541 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10542 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10543 dgst_size = DGST_SIZE_4_5;
10544 parse_func = veracrypt_parse_hash_655331;
10545 sort_by_digest = sort_by_digest_4_5;
10546 opti_type = OPTI_TYPE_ZERO_BYTE;
10547 dgst_pos0 = 0;
10548 dgst_pos1 = 1;
10549 dgst_pos2 = 2;
10550 dgst_pos3 = 3;
10551 break;
10552
10553 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10554 salt_type = SALT_TYPE_EMBEDDED;
10555 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10556 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10557 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10558 dgst_size = DGST_SIZE_4_5;
10559 parse_func = veracrypt_parse_hash_655331;
10560 sort_by_digest = sort_by_digest_4_5;
10561 opti_type = OPTI_TYPE_ZERO_BYTE;
10562 dgst_pos0 = 0;
10563 dgst_pos1 = 1;
10564 dgst_pos2 = 2;
10565 dgst_pos3 = 3;
10566 break;
10567
10568 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10569 salt_type = SALT_TYPE_EMBEDDED;
10570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10571 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10572 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10573 dgst_size = DGST_SIZE_4_5;
10574 parse_func = veracrypt_parse_hash_655331;
10575 sort_by_digest = sort_by_digest_4_5;
10576 opti_type = OPTI_TYPE_ZERO_BYTE;
10577 dgst_pos0 = 0;
10578 dgst_pos1 = 1;
10579 dgst_pos2 = 2;
10580 dgst_pos3 = 3;
10581 break;
10582
10583 case 13721: hash_type = HASH_TYPE_SHA512;
10584 salt_type = SALT_TYPE_EMBEDDED;
10585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10586 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10587 kern_type = KERN_TYPE_TCSHA512_XTS512;
10588 dgst_size = DGST_SIZE_8_8;
10589 parse_func = veracrypt_parse_hash_500000;
10590 sort_by_digest = sort_by_digest_8_8;
10591 opti_type = OPTI_TYPE_ZERO_BYTE
10592 | OPTI_TYPE_USES_BITS_64;
10593 dgst_pos0 = 0;
10594 dgst_pos1 = 1;
10595 dgst_pos2 = 2;
10596 dgst_pos3 = 3;
10597 break;
10598
10599 case 13722: hash_type = HASH_TYPE_SHA512;
10600 salt_type = SALT_TYPE_EMBEDDED;
10601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10602 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10603 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10604 dgst_size = DGST_SIZE_8_8;
10605 parse_func = veracrypt_parse_hash_500000;
10606 sort_by_digest = sort_by_digest_8_8;
10607 opti_type = OPTI_TYPE_ZERO_BYTE
10608 | OPTI_TYPE_USES_BITS_64;
10609 dgst_pos0 = 0;
10610 dgst_pos1 = 1;
10611 dgst_pos2 = 2;
10612 dgst_pos3 = 3;
10613 break;
10614
10615 case 13723: hash_type = HASH_TYPE_SHA512;
10616 salt_type = SALT_TYPE_EMBEDDED;
10617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10618 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10619 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10620 dgst_size = DGST_SIZE_8_8;
10621 parse_func = veracrypt_parse_hash_500000;
10622 sort_by_digest = sort_by_digest_8_8;
10623 opti_type = OPTI_TYPE_ZERO_BYTE
10624 | OPTI_TYPE_USES_BITS_64;
10625 dgst_pos0 = 0;
10626 dgst_pos1 = 1;
10627 dgst_pos2 = 2;
10628 dgst_pos3 = 3;
10629 break;
10630
10631 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10632 salt_type = SALT_TYPE_EMBEDDED;
10633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10635 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10636 dgst_size = DGST_SIZE_4_8;
10637 parse_func = veracrypt_parse_hash_500000;
10638 sort_by_digest = sort_by_digest_4_8;
10639 opti_type = OPTI_TYPE_ZERO_BYTE;
10640 dgst_pos0 = 0;
10641 dgst_pos1 = 1;
10642 dgst_pos2 = 2;
10643 dgst_pos3 = 3;
10644 break;
10645
10646 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10647 salt_type = SALT_TYPE_EMBEDDED;
10648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10650 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10651 dgst_size = DGST_SIZE_4_8;
10652 parse_func = veracrypt_parse_hash_500000;
10653 sort_by_digest = sort_by_digest_4_8;
10654 opti_type = OPTI_TYPE_ZERO_BYTE;
10655 dgst_pos0 = 0;
10656 dgst_pos1 = 1;
10657 dgst_pos2 = 2;
10658 dgst_pos3 = 3;
10659 break;
10660
10661 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10662 salt_type = SALT_TYPE_EMBEDDED;
10663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10665 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10666 dgst_size = DGST_SIZE_4_8;
10667 parse_func = veracrypt_parse_hash_500000;
10668 sort_by_digest = sort_by_digest_4_8;
10669 opti_type = OPTI_TYPE_ZERO_BYTE;
10670 dgst_pos0 = 0;
10671 dgst_pos1 = 1;
10672 dgst_pos2 = 2;
10673 dgst_pos3 = 3;
10674 break;
10675
10676 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10677 salt_type = SALT_TYPE_EMBEDDED;
10678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10680 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10681 dgst_size = DGST_SIZE_4_5;
10682 parse_func = veracrypt_parse_hash_327661;
10683 sort_by_digest = sort_by_digest_4_5;
10684 opti_type = OPTI_TYPE_ZERO_BYTE;
10685 dgst_pos0 = 0;
10686 dgst_pos1 = 1;
10687 dgst_pos2 = 2;
10688 dgst_pos3 = 3;
10689 break;
10690
10691 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10692 salt_type = SALT_TYPE_EMBEDDED;
10693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10695 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10696 dgst_size = DGST_SIZE_4_5;
10697 parse_func = veracrypt_parse_hash_327661;
10698 sort_by_digest = sort_by_digest_4_5;
10699 opti_type = OPTI_TYPE_ZERO_BYTE;
10700 dgst_pos0 = 0;
10701 dgst_pos1 = 1;
10702 dgst_pos2 = 2;
10703 dgst_pos3 = 3;
10704 break;
10705
10706 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10707 salt_type = SALT_TYPE_EMBEDDED;
10708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10710 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10711 dgst_size = DGST_SIZE_4_5;
10712 parse_func = veracrypt_parse_hash_327661;
10713 sort_by_digest = sort_by_digest_4_5;
10714 opti_type = OPTI_TYPE_ZERO_BYTE;
10715 dgst_pos0 = 0;
10716 dgst_pos1 = 1;
10717 dgst_pos2 = 2;
10718 dgst_pos3 = 3;
10719 break;
10720
10721 case 13751: hash_type = HASH_TYPE_SHA256;
10722 salt_type = SALT_TYPE_EMBEDDED;
10723 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10724 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10725 kern_type = KERN_TYPE_VCSHA256_XTS512;
10726 dgst_size = DGST_SIZE_4_8;
10727 parse_func = veracrypt_parse_hash_500000;
10728 sort_by_digest = sort_by_digest_4_8;
10729 opti_type = OPTI_TYPE_ZERO_BYTE;
10730 dgst_pos0 = 0;
10731 dgst_pos1 = 1;
10732 dgst_pos2 = 2;
10733 dgst_pos3 = 3;
10734 break;
10735
10736 case 13752: hash_type = HASH_TYPE_SHA256;
10737 salt_type = SALT_TYPE_EMBEDDED;
10738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10739 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10740 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10741 dgst_size = DGST_SIZE_4_8;
10742 parse_func = veracrypt_parse_hash_500000;
10743 sort_by_digest = sort_by_digest_4_8;
10744 opti_type = OPTI_TYPE_ZERO_BYTE;
10745 dgst_pos0 = 0;
10746 dgst_pos1 = 1;
10747 dgst_pos2 = 2;
10748 dgst_pos3 = 3;
10749 break;
10750
10751 case 13753: hash_type = HASH_TYPE_SHA256;
10752 salt_type = SALT_TYPE_EMBEDDED;
10753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10754 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10755 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10756 dgst_size = DGST_SIZE_4_8;
10757 parse_func = veracrypt_parse_hash_500000;
10758 sort_by_digest = sort_by_digest_4_8;
10759 opti_type = OPTI_TYPE_ZERO_BYTE;
10760 dgst_pos0 = 0;
10761 dgst_pos1 = 1;
10762 dgst_pos2 = 2;
10763 dgst_pos3 = 3;
10764 break;
10765
10766 case 13761: hash_type = HASH_TYPE_SHA256;
10767 salt_type = SALT_TYPE_EMBEDDED;
10768 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10769 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10770 kern_type = KERN_TYPE_VCSHA256_XTS512;
10771 dgst_size = DGST_SIZE_4_8;
10772 parse_func = veracrypt_parse_hash_200000;
10773 sort_by_digest = sort_by_digest_4_8;
10774 opti_type = OPTI_TYPE_ZERO_BYTE;
10775 dgst_pos0 = 0;
10776 dgst_pos1 = 1;
10777 dgst_pos2 = 2;
10778 dgst_pos3 = 3;
10779 break;
10780
10781 case 13762: hash_type = HASH_TYPE_SHA256;
10782 salt_type = SALT_TYPE_EMBEDDED;
10783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10784 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10785 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10786 dgst_size = DGST_SIZE_4_8;
10787 parse_func = veracrypt_parse_hash_200000;
10788 sort_by_digest = sort_by_digest_4_8;
10789 opti_type = OPTI_TYPE_ZERO_BYTE;
10790 dgst_pos0 = 0;
10791 dgst_pos1 = 1;
10792 dgst_pos2 = 2;
10793 dgst_pos3 = 3;
10794 break;
10795
10796 case 13763: hash_type = HASH_TYPE_SHA256;
10797 salt_type = SALT_TYPE_EMBEDDED;
10798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10799 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10800 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10801 dgst_size = DGST_SIZE_4_8;
10802 parse_func = veracrypt_parse_hash_200000;
10803 sort_by_digest = sort_by_digest_4_8;
10804 opti_type = OPTI_TYPE_ZERO_BYTE;
10805 dgst_pos0 = 0;
10806 dgst_pos1 = 1;
10807 dgst_pos2 = 2;
10808 dgst_pos3 = 3;
10809 break;
10810
10811
10812 default: usage_mini_print (PROGNAME); return (-1);
10813 }
10814
10815 /**
10816 * parser
10817 */
10818
10819 data.parse_func = parse_func;
10820
10821 /**
10822 * misc stuff
10823 */
10824
10825 if (hex_salt)
10826 {
10827 if (salt_type == SALT_TYPE_INTERN)
10828 {
10829 opts_type |= OPTS_TYPE_ST_HEX;
10830 }
10831 else
10832 {
10833 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10834
10835 return (-1);
10836 }
10837 }
10838
10839 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10840 | (salt_type == SALT_TYPE_EXTERN)
10841 | (salt_type == SALT_TYPE_EMBEDDED)
10842 | (salt_type == SALT_TYPE_VIRTUAL));
10843
10844 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10845
10846 data.hash_type = hash_type;
10847 data.attack_mode = attack_mode;
10848 data.attack_kern = attack_kern;
10849 data.attack_exec = attack_exec;
10850 data.kern_type = kern_type;
10851 data.opts_type = opts_type;
10852 data.dgst_size = dgst_size;
10853 data.salt_type = salt_type;
10854 data.isSalted = isSalted;
10855 data.sort_by_digest = sort_by_digest;
10856 data.dgst_pos0 = dgst_pos0;
10857 data.dgst_pos1 = dgst_pos1;
10858 data.dgst_pos2 = dgst_pos2;
10859 data.dgst_pos3 = dgst_pos3;
10860
10861 esalt_size = 0;
10862
10863 switch (hash_mode)
10864 {
10865 case 2500: esalt_size = sizeof (wpa_t); break;
10866 case 5300: esalt_size = sizeof (ikepsk_t); break;
10867 case 5400: esalt_size = sizeof (ikepsk_t); break;
10868 case 5500: esalt_size = sizeof (netntlm_t); break;
10869 case 5600: esalt_size = sizeof (netntlm_t); break;
10870 case 6211: esalt_size = sizeof (tc_t); break;
10871 case 6212: esalt_size = sizeof (tc_t); break;
10872 case 6213: esalt_size = sizeof (tc_t); break;
10873 case 6221: esalt_size = sizeof (tc_t); break;
10874 case 6222: esalt_size = sizeof (tc_t); break;
10875 case 6223: esalt_size = sizeof (tc_t); break;
10876 case 6231: esalt_size = sizeof (tc_t); break;
10877 case 6232: esalt_size = sizeof (tc_t); break;
10878 case 6233: esalt_size = sizeof (tc_t); break;
10879 case 6241: esalt_size = sizeof (tc_t); break;
10880 case 6242: esalt_size = sizeof (tc_t); break;
10881 case 6243: esalt_size = sizeof (tc_t); break;
10882 case 6600: esalt_size = sizeof (agilekey_t); break;
10883 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10884 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10885 case 7300: esalt_size = sizeof (rakp_t); break;
10886 case 7500: esalt_size = sizeof (krb5pa_t); break;
10887 case 8200: esalt_size = sizeof (cloudkey_t); break;
10888 case 8800: esalt_size = sizeof (androidfde_t); break;
10889 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10890 case 9400: esalt_size = sizeof (office2007_t); break;
10891 case 9500: esalt_size = sizeof (office2010_t); break;
10892 case 9600: esalt_size = sizeof (office2013_t); break;
10893 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10894 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10895 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10896 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10897 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10898 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10899 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10900 case 10200: esalt_size = sizeof (cram_md5_t); break;
10901 case 10400: esalt_size = sizeof (pdf_t); break;
10902 case 10410: esalt_size = sizeof (pdf_t); break;
10903 case 10420: esalt_size = sizeof (pdf_t); break;
10904 case 10500: esalt_size = sizeof (pdf_t); break;
10905 case 10600: esalt_size = sizeof (pdf_t); break;
10906 case 10700: esalt_size = sizeof (pdf_t); break;
10907 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10908 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10909 case 11400: esalt_size = sizeof (sip_t); break;
10910 case 11600: esalt_size = sizeof (seven_zip_t); break;
10911 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10912 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10913 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10914 case 13000: esalt_size = sizeof (rar5_t); break;
10915 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10916 case 13400: esalt_size = sizeof (keepass_t); break;
10917 case 13500: esalt_size = sizeof (pstoken_t); break;
10918 case 13600: esalt_size = sizeof (zip2_t); break;
10919 case 13711: esalt_size = sizeof (tc_t); break;
10920 case 13712: esalt_size = sizeof (tc_t); break;
10921 case 13713: esalt_size = sizeof (tc_t); break;
10922 case 13721: esalt_size = sizeof (tc_t); break;
10923 case 13722: esalt_size = sizeof (tc_t); break;
10924 case 13723: esalt_size = sizeof (tc_t); break;
10925 case 13731: esalt_size = sizeof (tc_t); break;
10926 case 13732: esalt_size = sizeof (tc_t); break;
10927 case 13733: esalt_size = sizeof (tc_t); break;
10928 case 13741: esalt_size = sizeof (tc_t); break;
10929 case 13742: esalt_size = sizeof (tc_t); break;
10930 case 13743: esalt_size = sizeof (tc_t); break;
10931 case 13751: esalt_size = sizeof (tc_t); break;
10932 case 13752: esalt_size = sizeof (tc_t); break;
10933 case 13753: esalt_size = sizeof (tc_t); break;
10934 case 13761: esalt_size = sizeof (tc_t); break;
10935 case 13762: esalt_size = sizeof (tc_t); break;
10936 case 13763: esalt_size = sizeof (tc_t); break;
10937 }
10938
10939 data.esalt_size = esalt_size;
10940
10941 /**
10942 * choose dictionary parser
10943 */
10944
10945 if (hash_type == HASH_TYPE_LM)
10946 {
10947 get_next_word_func = get_next_word_lm;
10948 }
10949 else if (opts_type & OPTS_TYPE_PT_UPPER)
10950 {
10951 get_next_word_func = get_next_word_uc;
10952 }
10953 else
10954 {
10955 get_next_word_func = get_next_word_std;
10956 }
10957
10958 /**
10959 * dictstat
10960 */
10961
10962 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10963
10964 #ifdef _POSIX
10965 size_t dictstat_nmemb = 0;
10966 #endif
10967
10968 #ifdef _WIN
10969 uint dictstat_nmemb = 0;
10970 #endif
10971
10972 char dictstat[256] = { 0 };
10973
10974 FILE *dictstat_fp = NULL;
10975
10976 if (keyspace == 0)
10977 {
10978 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10979
10980 dictstat_fp = fopen (dictstat, "rb");
10981
10982 if (dictstat_fp)
10983 {
10984 #ifdef _POSIX
10985 struct stat tmpstat;
10986
10987 fstat (fileno (dictstat_fp), &tmpstat);
10988 #endif
10989
10990 #ifdef _WIN
10991 struct stat64 tmpstat;
10992
10993 _fstat64 (fileno (dictstat_fp), &tmpstat);
10994 #endif
10995
10996 if (tmpstat.st_mtime < COMPTIME)
10997 {
10998 /* with v0.15 the format changed so we have to ensure user is using a good version
10999 since there is no version-header in the dictstat file */
11000
11001 fclose (dictstat_fp);
11002
11003 unlink (dictstat);
11004 }
11005 else
11006 {
11007 while (!feof (dictstat_fp))
11008 {
11009 dictstat_t d;
11010
11011 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11012
11013 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11014
11015 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11016 {
11017 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11018
11019 return -1;
11020 }
11021 }
11022
11023 fclose (dictstat_fp);
11024 }
11025 }
11026 }
11027
11028 /**
11029 * potfile
11030 */
11031
11032 char potfile[256] = { 0 };
11033
11034 if (potfile_path == NULL)
11035 {
11036 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11037 }
11038 else
11039 {
11040 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11041 }
11042
11043 data.pot_fp = NULL;
11044
11045 FILE *out_fp = NULL;
11046 FILE *pot_fp = NULL;
11047
11048 if (show == 1 || left == 1)
11049 {
11050 pot_fp = fopen (potfile, "rb");
11051
11052 if (pot_fp == NULL)
11053 {
11054 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11055
11056 return (-1);
11057 }
11058
11059 if (outfile != NULL)
11060 {
11061 if ((out_fp = fopen (outfile, "ab")) == NULL)
11062 {
11063 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11064
11065 fclose (pot_fp);
11066
11067 return (-1);
11068 }
11069 }
11070 else
11071 {
11072 out_fp = stdout;
11073 }
11074 }
11075 else
11076 {
11077 if (potfile_disable == 0)
11078 {
11079 pot_fp = fopen (potfile, "ab");
11080
11081 if (pot_fp == NULL)
11082 {
11083 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11084
11085 return (-1);
11086 }
11087
11088 data.pot_fp = pot_fp;
11089 }
11090 }
11091
11092 pot_t *pot = NULL;
11093
11094 uint pot_cnt = 0;
11095 uint pot_avail = 0;
11096
11097 if (show == 1 || left == 1)
11098 {
11099 SUPPRESS_OUTPUT = 1;
11100
11101 pot_avail = count_lines (pot_fp);
11102
11103 rewind (pot_fp);
11104
11105 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11106
11107 uint pot_hashes_avail = 0;
11108
11109 uint line_num = 0;
11110
11111 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11112
11113 while (!feof (pot_fp))
11114 {
11115 line_num++;
11116
11117 int line_len = fgetl (pot_fp, line_buf);
11118
11119 if (line_len == 0) continue;
11120
11121 char *plain_buf = line_buf + line_len;
11122
11123 pot_t *pot_ptr = &pot[pot_cnt];
11124
11125 hash_t *hashes_buf = &pot_ptr->hash;
11126
11127 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11128 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11129
11130 if (pot_cnt == pot_hashes_avail)
11131 {
11132 uint pos = 0;
11133
11134 for (pos = 0; pos < INCR_POT; pos++)
11135 {
11136 if ((pot_cnt + pos) >= pot_avail) break;
11137
11138 pot_t *tmp_pot = &pot[pot_cnt + pos];
11139
11140 hash_t *tmp_hash = &tmp_pot->hash;
11141
11142 tmp_hash->digest = mymalloc (dgst_size);
11143
11144 if (isSalted)
11145 {
11146 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11147 }
11148
11149 if (esalt_size)
11150 {
11151 tmp_hash->esalt = mymalloc (esalt_size);
11152 }
11153
11154 pot_hashes_avail++;
11155 }
11156 }
11157
11158 int plain_len = 0;
11159
11160 int parser_status;
11161
11162 int iter = MAX_CUT_TRIES;
11163
11164 do
11165 {
11166 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11167 {
11168 if (line_buf[i] == ':')
11169 {
11170 line_len--;
11171
11172 break;
11173 }
11174 }
11175
11176 if (data.hash_mode != 2500)
11177 {
11178 parser_status = parse_func (line_buf, line_len, hashes_buf);
11179 }
11180 else
11181 {
11182 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11183
11184 if (line_len > max_salt_size)
11185 {
11186 parser_status = PARSER_GLOBAL_LENGTH;
11187 }
11188 else
11189 {
11190 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11191
11192 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11193
11194 hashes_buf->salt->salt_len = line_len;
11195
11196 parser_status = PARSER_OK;
11197 }
11198 }
11199
11200 // if NOT parsed without error, we add the ":" to the plain
11201
11202 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11203 {
11204 plain_len++;
11205 plain_buf--;
11206 }
11207
11208 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11209
11210 if (parser_status < PARSER_GLOBAL_ZERO)
11211 {
11212 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11213
11214 continue;
11215 }
11216
11217 if (plain_len >= 255) continue;
11218
11219 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11220
11221 pot_ptr->plain_len = plain_len;
11222
11223 pot_cnt++;
11224 }
11225
11226 myfree (line_buf);
11227
11228 fclose (pot_fp);
11229
11230 SUPPRESS_OUTPUT = 0;
11231
11232 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11233 }
11234
11235 /**
11236 * word len
11237 */
11238
11239 uint pw_min = PW_MIN;
11240 uint pw_max = PW_MAX;
11241
11242 switch (hash_mode)
11243 {
11244 case 125: if (pw_max > 32) pw_max = 32;
11245 break;
11246 case 400: if (pw_max > 40) pw_max = 40;
11247 break;
11248 case 500: if (pw_max > 16) pw_max = 16;
11249 break;
11250 case 1500: if (pw_max > 8) pw_max = 8;
11251 break;
11252 case 1600: if (pw_max > 16) pw_max = 16;
11253 break;
11254 case 1800: if (pw_max > 16) pw_max = 16;
11255 break;
11256 case 2100: if (pw_max > 16) pw_max = 16;
11257 break;
11258 case 2500: if (pw_min < 8) pw_min = 8;
11259 break;
11260 case 3000: if (pw_max > 7) pw_max = 7;
11261 break;
11262 case 5200: if (pw_max > 24) pw_max = 24;
11263 break;
11264 case 5800: if (pw_max > 16) pw_max = 16;
11265 break;
11266 case 6300: if (pw_max > 16) pw_max = 16;
11267 break;
11268 case 7400: if (pw_max > 16) pw_max = 16;
11269 break;
11270 case 7500: if (pw_max > 8) pw_max = 8;
11271 break;
11272 case 7900: if (pw_max > 48) pw_max = 48;
11273 break;
11274 case 8500: if (pw_max > 8) pw_max = 8;
11275 break;
11276 case 8600: if (pw_max > 16) pw_max = 16;
11277 break;
11278 case 9710: pw_min = 5;
11279 pw_max = 5;
11280 break;
11281 case 9810: pw_min = 5;
11282 pw_max = 5;
11283 break;
11284 case 10410: pw_min = 5;
11285 pw_max = 5;
11286 break;
11287 case 10300: if (pw_max < 3) pw_min = 3;
11288 if (pw_max > 40) pw_max = 40;
11289 break;
11290 case 10500: if (pw_max < 3) pw_min = 3;
11291 if (pw_max > 40) pw_max = 40;
11292 break;
11293 case 10700: if (pw_max > 16) pw_max = 16;
11294 break;
11295 case 11300: if (pw_max > 40) pw_max = 40;
11296 break;
11297 case 11600: if (pw_max > 32) pw_max = 32;
11298 break;
11299 case 12500: if (pw_max > 20) pw_max = 20;
11300 break;
11301 case 12800: if (pw_max > 24) pw_max = 24;
11302 break;
11303 }
11304
11305 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11306 {
11307 switch (attack_kern)
11308 {
11309 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11310 break;
11311 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11312 break;
11313 }
11314 }
11315
11316 /**
11317 * charsets : keep them together for more easy maintainnce
11318 */
11319
11320 cs_t mp_sys[6] = { { { 0 }, 0 } };
11321 cs_t mp_usr[4] = { { { 0 }, 0 } };
11322
11323 mp_setup_sys (mp_sys);
11324
11325 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11326 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11327 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11328 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11329
11330 /**
11331 * load hashes, part I: find input mode, count hashes
11332 */
11333
11334 uint hashlist_mode = 0;
11335 uint hashlist_format = HLFMT_HASHCAT;
11336
11337 uint hashes_avail = 0;
11338
11339 if (benchmark == 0)
11340 {
11341 struct stat f;
11342
11343 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11344
11345 if ((hash_mode == 2500) ||
11346 (hash_mode == 5200) ||
11347 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11348 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11349 (hash_mode == 9000))
11350 {
11351 hashlist_mode = HL_MODE_ARG;
11352
11353 char *hashfile = myargv[optind];
11354
11355 data.hashfile = hashfile;
11356
11357 logfile_top_var_string ("target", hashfile);
11358 }
11359
11360 if (hashlist_mode == HL_MODE_ARG)
11361 {
11362 if (hash_mode == 2500)
11363 {
11364 struct stat st;
11365
11366 if (stat (data.hashfile, &st) == -1)
11367 {
11368 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11369
11370 return (-1);
11371 }
11372
11373 hashes_avail = st.st_size / sizeof (hccap_t);
11374 }
11375 else
11376 {
11377 hashes_avail = 1;
11378 }
11379 }
11380 else if (hashlist_mode == HL_MODE_FILE)
11381 {
11382 char *hashfile = myargv[optind];
11383
11384 data.hashfile = hashfile;
11385
11386 logfile_top_var_string ("target", hashfile);
11387
11388 FILE *fp = NULL;
11389
11390 if ((fp = fopen (hashfile, "rb")) == NULL)
11391 {
11392 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11393
11394 return (-1);
11395 }
11396
11397 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11398
11399 hashes_avail = count_lines (fp);
11400
11401 rewind (fp);
11402
11403 if (hashes_avail == 0)
11404 {
11405 log_error ("ERROR: hashfile is empty or corrupt");
11406
11407 fclose (fp);
11408
11409 return (-1);
11410 }
11411
11412 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11413
11414 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11415 {
11416 log_error ("ERROR: remove not supported in native hashfile-format mode");
11417
11418 fclose (fp);
11419
11420 return (-1);
11421 }
11422
11423 fclose (fp);
11424 }
11425 }
11426 else
11427 {
11428 hashlist_mode = HL_MODE_ARG;
11429
11430 hashes_avail = 1;
11431 }
11432
11433 if (hash_mode == 3000) hashes_avail *= 2;
11434
11435 data.hashlist_mode = hashlist_mode;
11436 data.hashlist_format = hashlist_format;
11437
11438 logfile_top_uint (hashlist_mode);
11439 logfile_top_uint (hashlist_format);
11440
11441 /**
11442 * load hashes, part II: allocate required memory, set pointers
11443 */
11444
11445 hash_t *hashes_buf = NULL;
11446 void *digests_buf = NULL;
11447 salt_t *salts_buf = NULL;
11448 void *esalts_buf = NULL;
11449
11450 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11451
11452 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11453
11454 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11455 {
11456 u32 hash_pos;
11457
11458 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11459 {
11460 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11461
11462 hashes_buf[hash_pos].hash_info = hash_info;
11463
11464 if (username && (remove || show || left))
11465 {
11466 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11467 }
11468
11469 if (benchmark)
11470 {
11471 hash_info->orighash = (char *) mymalloc (256);
11472 }
11473 }
11474 }
11475
11476 if (isSalted)
11477 {
11478 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11479
11480 if (esalt_size)
11481 {
11482 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11483 }
11484 }
11485 else
11486 {
11487 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11488 }
11489
11490 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11491 {
11492 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11493
11494 if (isSalted)
11495 {
11496 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11497
11498 if (esalt_size)
11499 {
11500 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11501 }
11502 }
11503 else
11504 {
11505 hashes_buf[hash_pos].salt = &salts_buf[0];
11506 }
11507 }
11508
11509 /**
11510 * load hashes, part III: parse hashes or generate them if benchmark
11511 */
11512
11513 uint hashes_cnt = 0;
11514
11515 if (benchmark == 0)
11516 {
11517 if (keyspace == 1)
11518 {
11519 // useless to read hash file for keyspace, cheat a little bit w/ optind
11520 }
11521 else if (hashes_avail == 0)
11522 {
11523 }
11524 else if (hashlist_mode == HL_MODE_ARG)
11525 {
11526 char *input_buf = myargv[optind];
11527
11528 uint input_len = strlen (input_buf);
11529
11530 logfile_top_var_string ("target", input_buf);
11531
11532 char *hash_buf = NULL;
11533 int hash_len = 0;
11534
11535 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11536
11537 bool hash_fmt_error = 0;
11538
11539 if (hash_len < 1) hash_fmt_error = 1;
11540 if (hash_buf == NULL) hash_fmt_error = 1;
11541
11542 if (hash_fmt_error)
11543 {
11544 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11545 }
11546 else
11547 {
11548 if (opts_type & OPTS_TYPE_HASH_COPY)
11549 {
11550 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11551
11552 hash_info_tmp->orighash = mystrdup (hash_buf);
11553 }
11554
11555 if (isSalted)
11556 {
11557 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11558 }
11559
11560 int parser_status = PARSER_OK;
11561
11562 if (hash_mode == 2500)
11563 {
11564 if (hash_len == 0)
11565 {
11566 log_error ("ERROR: hccap file not specified");
11567
11568 return (-1);
11569 }
11570
11571 hashlist_mode = HL_MODE_FILE;
11572
11573 data.hashlist_mode = hashlist_mode;
11574
11575 FILE *fp = fopen (hash_buf, "rb");
11576
11577 if (fp == NULL)
11578 {
11579 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11580
11581 return (-1);
11582 }
11583
11584 if (hashes_avail < 1)
11585 {
11586 log_error ("ERROR: hccap file is empty or corrupt");
11587
11588 fclose (fp);
11589
11590 return (-1);
11591 }
11592
11593 uint hccap_size = sizeof (hccap_t);
11594
11595 char *in = (char *) mymalloc (hccap_size);
11596
11597 while (!feof (fp))
11598 {
11599 int n = fread (in, hccap_size, 1, fp);
11600
11601 if (n != 1)
11602 {
11603 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11604
11605 break;
11606 }
11607
11608 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11609
11610 if (parser_status != PARSER_OK)
11611 {
11612 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11613
11614 continue;
11615 }
11616
11617 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11618
11619 if ((show == 1) || (left == 1))
11620 {
11621 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11622
11623 char *salt_ptr = (char *) tmp_salt->salt_buf;
11624
11625 int cur_pos = tmp_salt->salt_len;
11626 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11627
11628 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11629
11630 // do the appending task
11631
11632 snprintf (salt_ptr + cur_pos,
11633 rem_len,
11634 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11635 wpa->orig_mac1[0],
11636 wpa->orig_mac1[1],
11637 wpa->orig_mac1[2],
11638 wpa->orig_mac1[3],
11639 wpa->orig_mac1[4],
11640 wpa->orig_mac1[5],
11641 wpa->orig_mac2[0],
11642 wpa->orig_mac2[1],
11643 wpa->orig_mac2[2],
11644 wpa->orig_mac2[3],
11645 wpa->orig_mac2[4],
11646 wpa->orig_mac2[5]);
11647
11648 // memset () the remaining part of the salt
11649
11650 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11651 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11652
11653 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11654
11655 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11656 }
11657
11658 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);
11659 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);
11660
11661 hashes_cnt++;
11662 }
11663
11664 fclose (fp);
11665
11666 myfree (in);
11667 }
11668 else if (hash_mode == 3000)
11669 {
11670 if (hash_len == 32)
11671 {
11672 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11673
11674 hash_t *lm_hash_left = NULL;
11675
11676 if (parser_status == PARSER_OK)
11677 {
11678 lm_hash_left = &hashes_buf[hashes_cnt];
11679
11680 hashes_cnt++;
11681 }
11682 else
11683 {
11684 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11685 }
11686
11687 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11688
11689 hash_t *lm_hash_right = NULL;
11690
11691 if (parser_status == PARSER_OK)
11692 {
11693 lm_hash_right = &hashes_buf[hashes_cnt];
11694
11695 hashes_cnt++;
11696 }
11697 else
11698 {
11699 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11700 }
11701
11702 // show / left
11703
11704 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11705 {
11706 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);
11707 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);
11708 }
11709 }
11710 else
11711 {
11712 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11713
11714 if (parser_status == PARSER_OK)
11715 {
11716 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11717 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11718 }
11719
11720 if (parser_status == PARSER_OK)
11721 {
11722 hashes_cnt++;
11723 }
11724 else
11725 {
11726 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11727 }
11728 }
11729 }
11730 else
11731 {
11732 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11733
11734 if (parser_status == PARSER_OK)
11735 {
11736 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11737 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11738 }
11739
11740 if (parser_status == PARSER_OK)
11741 {
11742 hashes_cnt++;
11743 }
11744 else
11745 {
11746 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11747 }
11748 }
11749 }
11750 }
11751 else if (hashlist_mode == HL_MODE_FILE)
11752 {
11753 char *hashfile = data.hashfile;
11754
11755 FILE *fp;
11756
11757 if ((fp = fopen (hashfile, "rb")) == NULL)
11758 {
11759 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11760
11761 return (-1);
11762 }
11763
11764 uint line_num = 0;
11765
11766 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11767
11768 while (!feof (fp))
11769 {
11770 line_num++;
11771
11772 int line_len = fgetl (fp, line_buf);
11773
11774 if (line_len == 0) continue;
11775
11776 char *hash_buf = NULL;
11777 int hash_len = 0;
11778
11779 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11780
11781 bool hash_fmt_error = 0;
11782
11783 if (hash_len < 1) hash_fmt_error = 1;
11784 if (hash_buf == NULL) hash_fmt_error = 1;
11785
11786 if (hash_fmt_error)
11787 {
11788 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11789
11790 continue;
11791 }
11792
11793 if (username)
11794 {
11795 char *user_buf = NULL;
11796 int user_len = 0;
11797
11798 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11799
11800 if (remove || show)
11801 {
11802 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11803
11804 *user = (user_t *) mymalloc (sizeof (user_t));
11805
11806 user_t *user_ptr = *user;
11807
11808 if (user_buf != NULL)
11809 {
11810 user_ptr->user_name = mystrdup (user_buf);
11811 }
11812 else
11813 {
11814 user_ptr->user_name = mystrdup ("");
11815 }
11816
11817 user_ptr->user_len = user_len;
11818 }
11819 }
11820
11821 if (opts_type & OPTS_TYPE_HASH_COPY)
11822 {
11823 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11824
11825 hash_info_tmp->orighash = mystrdup (hash_buf);
11826 }
11827
11828 if (isSalted)
11829 {
11830 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11831 }
11832
11833 if (hash_mode == 3000)
11834 {
11835 if (hash_len == 32)
11836 {
11837 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11838
11839 if (parser_status < PARSER_GLOBAL_ZERO)
11840 {
11841 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11842
11843 continue;
11844 }
11845
11846 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11847
11848 hashes_cnt++;
11849
11850 parser_status = parse_func (hash_buf + 16, 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_right = &hashes_buf[hashes_cnt];
11860
11861 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);
11862
11863 hashes_cnt++;
11864
11865 // show / left
11866
11867 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);
11868 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);
11869 }
11870 else
11871 {
11872 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11873
11874 if (parser_status < PARSER_GLOBAL_ZERO)
11875 {
11876 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11877
11878 continue;
11879 }
11880
11881 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);
11882
11883 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11884 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11885
11886 hashes_cnt++;
11887 }
11888 }
11889 else
11890 {
11891 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11892
11893 if (parser_status < PARSER_GLOBAL_ZERO)
11894 {
11895 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11896
11897 continue;
11898 }
11899
11900 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);
11901
11902 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11903 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11904
11905 hashes_cnt++;
11906 }
11907 }
11908
11909 myfree (line_buf);
11910
11911 fclose (fp);
11912
11913 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11914
11915 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11916 }
11917 }
11918 else
11919 {
11920 if (isSalted)
11921 {
11922 hashes_buf[0].salt->salt_len = 8;
11923
11924 // special salt handling
11925
11926 switch (hash_mode)
11927 {
11928 case 1500: hashes_buf[0].salt->salt_len = 2;
11929 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11930 break;
11931 case 1731: hashes_buf[0].salt->salt_len = 4;
11932 break;
11933 case 2410: hashes_buf[0].salt->salt_len = 4;
11934 break;
11935 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11936 break;
11937 case 3100: hashes_buf[0].salt->salt_len = 1;
11938 break;
11939 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11940 break;
11941 case 5800: hashes_buf[0].salt->salt_len = 16;
11942 break;
11943 case 6800: hashes_buf[0].salt->salt_len = 32;
11944 break;
11945 case 8400: hashes_buf[0].salt->salt_len = 40;
11946 break;
11947 case 8800: hashes_buf[0].salt->salt_len = 16;
11948 break;
11949 case 8900: hashes_buf[0].salt->salt_len = 16;
11950 hashes_buf[0].salt->scrypt_N = 1024;
11951 hashes_buf[0].salt->scrypt_r = 1;
11952 hashes_buf[0].salt->scrypt_p = 1;
11953 break;
11954 case 9100: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 9300: hashes_buf[0].salt->salt_len = 14;
11957 hashes_buf[0].salt->scrypt_N = 16384;
11958 hashes_buf[0].salt->scrypt_r = 1;
11959 hashes_buf[0].salt->scrypt_p = 1;
11960 break;
11961 case 9400: hashes_buf[0].salt->salt_len = 16;
11962 break;
11963 case 9500: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9600: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 9700: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9710: hashes_buf[0].salt->salt_len = 16;
11970 break;
11971 case 9720: hashes_buf[0].salt->salt_len = 16;
11972 break;
11973 case 9800: hashes_buf[0].salt->salt_len = 16;
11974 break;
11975 case 9810: hashes_buf[0].salt->salt_len = 16;
11976 break;
11977 case 9820: hashes_buf[0].salt->salt_len = 16;
11978 break;
11979 case 10300: hashes_buf[0].salt->salt_len = 12;
11980 break;
11981 case 11500: hashes_buf[0].salt->salt_len = 4;
11982 break;
11983 case 11600: hashes_buf[0].salt->salt_len = 4;
11984 break;
11985 case 12400: hashes_buf[0].salt->salt_len = 4;
11986 break;
11987 case 12500: hashes_buf[0].salt->salt_len = 8;
11988 break;
11989 case 12600: hashes_buf[0].salt->salt_len = 64;
11990 break;
11991 }
11992
11993 // special esalt handling
11994
11995 switch (hash_mode)
11996 {
11997 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11998 break;
11999 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12000 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12001 break;
12002 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12003 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12004 break;
12005 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12006 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12007 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12008 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12009 break;
12010 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12011 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12012 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12013 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12014 break;
12015 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12016 break;
12017 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12018 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12019 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12020 break;
12021 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12022 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12023 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12024 break;
12025 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12026 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12027 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12028 break;
12029 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12030 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12031 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12032 break;
12033 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12034 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12035 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12036 break;
12037 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12038 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12039 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12040 break;
12041 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12042 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12043 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12044 break;
12045 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12046 break;
12047 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12048 break;
12049 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12050 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12051 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12052 break;
12053 }
12054 }
12055
12056 // set hashfile
12057
12058 switch (hash_mode)
12059 {
12060 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12061 break;
12062 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12063 break;
12064 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12065 break;
12066 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12067 break;
12068 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12079 break;
12080 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12081 break;
12082 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12083 break;
12084 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12085 break;
12086 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12087 break;
12088 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12089 break;
12090 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12091 break;
12092 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12093 break;
12094 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12095 break;
12096 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12097 break;
12098 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12121 break;
12122 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12123 break;
12124 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12125 break;
12126 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12127 break;
12128 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12129 break;
12130 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12131 break;
12132 }
12133
12134 // set default iterations
12135
12136 switch (hash_mode)
12137 {
12138 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12139 break;
12140 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12141 break;
12142 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12143 break;
12144 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12145 break;
12146 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12147 break;
12148 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12149 break;
12150 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12151 break;
12152 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12153 break;
12154 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12155 break;
12156 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12157 break;
12158 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12159 break;
12160 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12161 break;
12162 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12163 break;
12164 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12165 break;
12166 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12171 break;
12172 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12173 break;
12174 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12175 break;
12176 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12177 break;
12178 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12179 break;
12180 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12181 break;
12182 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12183 break;
12184 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12185 break;
12186 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12187 break;
12188 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12189 break;
12190 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12191 break;
12192 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12193 break;
12194 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12195 break;
12196 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12197 break;
12198 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12199 break;
12200 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12201 break;
12202 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12203 break;
12204 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12205 break;
12206 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12207 break;
12208 case 8900: hashes_buf[0].salt->salt_iter = 1;
12209 break;
12210 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12211 break;
12212 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12213 break;
12214 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12215 break;
12216 case 9300: hashes_buf[0].salt->salt_iter = 1;
12217 break;
12218 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12219 break;
12220 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12221 break;
12222 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12223 break;
12224 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12225 break;
12226 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12227 break;
12228 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12229 break;
12230 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12231 break;
12232 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12233 break;
12234 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12235 break;
12236 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12237 break;
12238 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12239 break;
12240 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12241 break;
12242 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12243 break;
12244 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12245 break;
12246 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12247 break;
12248 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12249 break;
12250 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12251 break;
12252 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12253 break;
12254 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12255 break;
12256 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12257 break;
12258 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12259 break;
12260 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12261 break;
12262 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12263 break;
12264 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12265 break;
12266 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12267 break;
12268 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12269 break;
12270 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12271 break;
12272 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12273 break;
12274 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12275 break;
12276 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12277 break;
12278 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12281 break;
12282 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12283 break;
12284 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12285 break;
12286 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12287 break;
12288 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12289 break;
12290 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12291 break;
12292 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12293 break;
12294 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12295 break;
12296 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12297 break;
12298 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12299 break;
12300 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12301 break;
12302 }
12303
12304 hashes_cnt = 1;
12305 }
12306
12307 if (show == 1 || left == 1)
12308 {
12309 for (uint i = 0; i < pot_cnt; i++)
12310 {
12311 pot_t *pot_ptr = &pot[i];
12312
12313 hash_t *hashes_buf = &pot_ptr->hash;
12314
12315 local_free (hashes_buf->digest);
12316
12317 if (isSalted)
12318 {
12319 local_free (hashes_buf->salt);
12320 }
12321 }
12322
12323 local_free (pot);
12324
12325 if (data.quiet == 0) log_info_nn ("");
12326
12327 return (0);
12328 }
12329
12330 if (keyspace == 0)
12331 {
12332 if (hashes_cnt == 0)
12333 {
12334 log_error ("ERROR: No hashes loaded");
12335
12336 return (-1);
12337 }
12338 }
12339
12340 /**
12341 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12342 */
12343
12344 if (data.outfile != NULL)
12345 {
12346 if (data.hashfile != NULL)
12347 {
12348 #ifdef _POSIX
12349 struct stat tmpstat_outfile;
12350 struct stat tmpstat_hashfile;
12351 #endif
12352
12353 #ifdef _WIN
12354 struct stat64 tmpstat_outfile;
12355 struct stat64 tmpstat_hashfile;
12356 #endif
12357
12358 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12359
12360 if (tmp_outfile_fp)
12361 {
12362 #ifdef _POSIX
12363 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12364 #endif
12365
12366 #ifdef _WIN
12367 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12368 #endif
12369
12370 fclose (tmp_outfile_fp);
12371 }
12372
12373 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12374
12375 if (tmp_hashfile_fp)
12376 {
12377 #ifdef _POSIX
12378 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12379 #endif
12380
12381 #ifdef _WIN
12382 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12383 #endif
12384
12385 fclose (tmp_hashfile_fp);
12386 }
12387
12388 if (tmp_outfile_fp && tmp_outfile_fp)
12389 {
12390 tmpstat_outfile.st_mode = 0;
12391 tmpstat_outfile.st_nlink = 0;
12392 tmpstat_outfile.st_uid = 0;
12393 tmpstat_outfile.st_gid = 0;
12394 tmpstat_outfile.st_rdev = 0;
12395 tmpstat_outfile.st_atime = 0;
12396
12397 tmpstat_hashfile.st_mode = 0;
12398 tmpstat_hashfile.st_nlink = 0;
12399 tmpstat_hashfile.st_uid = 0;
12400 tmpstat_hashfile.st_gid = 0;
12401 tmpstat_hashfile.st_rdev = 0;
12402 tmpstat_hashfile.st_atime = 0;
12403
12404 #ifdef _POSIX
12405 tmpstat_outfile.st_blksize = 0;
12406 tmpstat_outfile.st_blocks = 0;
12407
12408 tmpstat_hashfile.st_blksize = 0;
12409 tmpstat_hashfile.st_blocks = 0;
12410 #endif
12411
12412 #ifdef _POSIX
12413 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12414 {
12415 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12416
12417 return (-1);
12418 }
12419 #endif
12420
12421 #ifdef _WIN
12422 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12423 {
12424 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12425
12426 return (-1);
12427 }
12428 #endif
12429 }
12430 }
12431 }
12432
12433 /**
12434 * Remove duplicates
12435 */
12436
12437 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12438
12439 if (isSalted)
12440 {
12441 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12442 }
12443 else
12444 {
12445 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12446 }
12447
12448 uint hashes_cnt_orig = hashes_cnt;
12449
12450 hashes_cnt = 1;
12451
12452 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12453 {
12454 if (isSalted)
12455 {
12456 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12457 {
12458 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12459 }
12460 }
12461 else
12462 {
12463 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12464 }
12465
12466 if (hashes_pos > hashes_cnt)
12467 {
12468 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12469 }
12470
12471 hashes_cnt++;
12472 }
12473
12474 /**
12475 * Potfile removes
12476 */
12477
12478 uint potfile_remove_cracks = 0;
12479
12480 if (potfile_disable == 0)
12481 {
12482 hash_t hash_buf;
12483
12484 hash_buf.digest = mymalloc (dgst_size);
12485 hash_buf.salt = NULL;
12486 hash_buf.esalt = NULL;
12487 hash_buf.hash_info = NULL;
12488 hash_buf.cracked = 0;
12489
12490 if (isSalted)
12491 {
12492 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12493 }
12494
12495 if (esalt_size)
12496 {
12497 hash_buf.esalt = mymalloc (esalt_size);
12498 }
12499
12500 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12501
12502 // no solution for these special hash types (for instane because they use hashfile in output etc)
12503 if ((hash_mode != 5200) &&
12504 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12505 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12506 (hash_mode != 9000))
12507 {
12508 FILE *fp = fopen (potfile, "rb");
12509
12510 if (fp != NULL)
12511 {
12512 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12513
12514 // to be safe work with a copy (because of line_len loop, i etc)
12515 // moved up here because it's easier to handle continue case
12516 // it's just 64kb
12517
12518 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12519
12520 while (!feof (fp))
12521 {
12522 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12523
12524 if (ptr == NULL) break;
12525
12526 int line_len = strlen (line_buf);
12527
12528 if (line_len == 0) continue;
12529
12530 int iter = MAX_CUT_TRIES;
12531
12532 for (int i = line_len - 1; i && iter; i--, line_len--)
12533 {
12534 if (line_buf[i] != ':') continue;
12535
12536 if (isSalted)
12537 {
12538 memset (hash_buf.salt, 0, sizeof (salt_t));
12539 }
12540
12541 hash_t *found = NULL;
12542
12543 if (hash_mode == 6800)
12544 {
12545 if (i < 64) // 64 = 16 * uint in salt_buf[]
12546 {
12547 // manipulate salt_buf
12548 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12549
12550 hash_buf.salt->salt_len = i;
12551
12552 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12553 }
12554 }
12555 else if (hash_mode == 2500)
12556 {
12557 if (i < 64) // 64 = 16 * uint in salt_buf[]
12558 {
12559 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12560 // manipulate salt_buf
12561
12562 memcpy (line_buf_cpy, line_buf, i);
12563
12564 char *mac2_pos = strrchr (line_buf_cpy, ':');
12565
12566 if (mac2_pos == NULL) continue;
12567
12568 mac2_pos[0] = 0;
12569 mac2_pos++;
12570
12571 if (strlen (mac2_pos) != 12) continue;
12572
12573 char *mac1_pos = strrchr (line_buf_cpy, ':');
12574
12575 if (mac1_pos == NULL) continue;
12576
12577 mac1_pos[0] = 0;
12578 mac1_pos++;
12579
12580 if (strlen (mac1_pos) != 12) continue;
12581
12582 uint essid_length = mac1_pos - line_buf_cpy - 1;
12583
12584 // here we need the ESSID
12585 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12586
12587 hash_buf.salt->salt_len = essid_length;
12588
12589 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12590
12591 if (found)
12592 {
12593 wpa_t *wpa = (wpa_t *) found->esalt;
12594
12595 // compare hex string(s) vs binary MAC address(es)
12596
12597 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12598 {
12599 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12600 {
12601 found = NULL;
12602
12603 break;
12604 }
12605 }
12606
12607 // early skip ;)
12608 if (!found) continue;
12609
12610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12611 {
12612 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12613 {
12614 found = NULL;
12615
12616 break;
12617 }
12618 }
12619 }
12620 }
12621 }
12622 else
12623 {
12624 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12625
12626 if (parser_status == PARSER_OK)
12627 {
12628 if (isSalted)
12629 {
12630 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12631 }
12632 else
12633 {
12634 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12635 }
12636 }
12637 }
12638
12639 if (found == NULL) continue;
12640
12641 if (!found->cracked) potfile_remove_cracks++;
12642
12643 found->cracked = 1;
12644
12645 if (found) break;
12646
12647 iter--;
12648 }
12649 }
12650
12651 myfree (line_buf_cpy);
12652
12653 myfree (line_buf);
12654
12655 fclose (fp);
12656 }
12657 }
12658
12659 if (esalt_size)
12660 {
12661 local_free (hash_buf.esalt);
12662 }
12663
12664 if (isSalted)
12665 {
12666 local_free (hash_buf.salt);
12667 }
12668
12669 local_free (hash_buf.digest);
12670 }
12671
12672 /**
12673 * Now generate all the buffers required for later
12674 */
12675
12676 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12677
12678 salt_t *salts_buf_new = NULL;
12679 void *esalts_buf_new = NULL;
12680
12681 if (isSalted)
12682 {
12683 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12684
12685 if (esalt_size)
12686 {
12687 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12688 }
12689 }
12690 else
12691 {
12692 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12693 }
12694
12695 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12696
12697 uint digests_cnt = hashes_cnt;
12698 uint digests_done = 0;
12699
12700 size_t size_digests = digests_cnt * dgst_size;
12701 size_t size_shown = digests_cnt * sizeof (uint);
12702
12703 uint *digests_shown = (uint *) mymalloc (size_shown);
12704 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12705
12706 uint salts_cnt = 0;
12707 uint salts_done = 0;
12708
12709 hashinfo_t **hash_info = NULL;
12710
12711 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12712 {
12713 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12714
12715 if (username && (remove || show))
12716 {
12717 uint user_pos;
12718
12719 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12720 {
12721 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12722
12723 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12724 }
12725 }
12726 }
12727
12728 uint *salts_shown = (uint *) mymalloc (size_shown);
12729
12730 salt_t *salt_buf;
12731
12732 {
12733 // copied from inner loop
12734
12735 salt_buf = &salts_buf_new[salts_cnt];
12736
12737 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12738
12739 if (esalt_size)
12740 {
12741 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12742 }
12743
12744 salt_buf->digests_cnt = 0;
12745 salt_buf->digests_done = 0;
12746 salt_buf->digests_offset = 0;
12747
12748 salts_cnt++;
12749 }
12750
12751 if (hashes_buf[0].cracked == 1)
12752 {
12753 digests_shown[0] = 1;
12754
12755 digests_done++;
12756
12757 salt_buf->digests_done++;
12758 }
12759
12760 salt_buf->digests_cnt++;
12761
12762 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12763
12764 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12765 {
12766 hash_info[0] = hashes_buf[0].hash_info;
12767 }
12768
12769 // copy from inner loop
12770
12771 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12772 {
12773 if (isSalted)
12774 {
12775 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12776 {
12777 salt_buf = &salts_buf_new[salts_cnt];
12778
12779 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12780
12781 if (esalt_size)
12782 {
12783 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12784 }
12785
12786 salt_buf->digests_cnt = 0;
12787 salt_buf->digests_done = 0;
12788 salt_buf->digests_offset = hashes_pos;
12789
12790 salts_cnt++;
12791 }
12792 }
12793
12794 if (hashes_buf[hashes_pos].cracked == 1)
12795 {
12796 digests_shown[hashes_pos] = 1;
12797
12798 digests_done++;
12799
12800 salt_buf->digests_done++;
12801 }
12802
12803 salt_buf->digests_cnt++;
12804
12805 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12806
12807 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12808 {
12809 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12810 }
12811 }
12812
12813 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12814 {
12815 salt_t *salt_buf = &salts_buf_new[salt_pos];
12816
12817 if (salt_buf->digests_done == salt_buf->digests_cnt)
12818 {
12819 salts_shown[salt_pos] = 1;
12820
12821 salts_done++;
12822 }
12823
12824 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12825 }
12826
12827 local_free (digests_buf);
12828 local_free (salts_buf);
12829 local_free (esalts_buf);
12830
12831 digests_buf = digests_buf_new;
12832 salts_buf = salts_buf_new;
12833 esalts_buf = esalts_buf_new;
12834
12835 local_free (hashes_buf);
12836
12837 /**
12838 * special modification not set from parser
12839 */
12840
12841 switch (hash_mode)
12842 {
12843 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12862 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12863 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12864 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12865 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12866 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12867 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12868 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12869 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12870 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12871 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12872 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12873 }
12874
12875 if (truecrypt_keyfiles)
12876 {
12877 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12878
12879 char *keyfiles = strdup (truecrypt_keyfiles);
12880
12881 char *keyfile = strtok (keyfiles, ",");
12882
12883 do
12884 {
12885 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12886
12887 } while ((keyfile = strtok (NULL, ",")) != NULL);
12888
12889 free (keyfiles);
12890 }
12891
12892 if (veracrypt_keyfiles)
12893 {
12894 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12895
12896 char *keyfiles = strdup (veracrypt_keyfiles);
12897
12898 char *keyfile = strtok (keyfiles, ",");
12899
12900 do
12901 {
12902 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12903
12904 } while ((keyfile = strtok (NULL, ",")) != NULL);
12905
12906 free (keyfiles);
12907 }
12908
12909 data.digests_cnt = digests_cnt;
12910 data.digests_done = digests_done;
12911 data.digests_buf = digests_buf;
12912 data.digests_shown = digests_shown;
12913 data.digests_shown_tmp = digests_shown_tmp;
12914
12915 data.salts_cnt = salts_cnt;
12916 data.salts_done = salts_done;
12917 data.salts_buf = salts_buf;
12918 data.salts_shown = salts_shown;
12919
12920 data.esalts_buf = esalts_buf;
12921 data.hash_info = hash_info;
12922
12923 /**
12924 * Automatic Optimizers
12925 */
12926
12927 if (salts_cnt == 1)
12928 opti_type |= OPTI_TYPE_SINGLE_SALT;
12929
12930 if (digests_cnt == 1)
12931 opti_type |= OPTI_TYPE_SINGLE_HASH;
12932
12933 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12934 opti_type |= OPTI_TYPE_NOT_ITERATED;
12935
12936 if (attack_mode == ATTACK_MODE_BF)
12937 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12938
12939 data.opti_type = opti_type;
12940
12941 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12942 {
12943 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12944 {
12945 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12946 {
12947 if (opts_type & OPTS_TYPE_ST_ADD80)
12948 {
12949 opts_type &= ~OPTS_TYPE_ST_ADD80;
12950 opts_type |= OPTS_TYPE_PT_ADD80;
12951 }
12952
12953 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12954 {
12955 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12956 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12957 }
12958
12959 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12960 {
12961 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12962 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12963 }
12964 }
12965 }
12966 }
12967
12968 /**
12969 * Some algorithm, like descrypt, can benefit from JIT compilation
12970 */
12971
12972 int force_jit_compilation = -1;
12973
12974 if (hash_mode == 8900)
12975 {
12976 force_jit_compilation = 8900;
12977 }
12978 else if (hash_mode == 9300)
12979 {
12980 force_jit_compilation = 8900;
12981 }
12982 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12983 {
12984 force_jit_compilation = 1500;
12985 }
12986
12987 /**
12988 * generate bitmap tables
12989 */
12990
12991 const uint bitmap_shift1 = 5;
12992 const uint bitmap_shift2 = 13;
12993
12994 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12995
12996 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12997 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12998 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12999 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13000 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13001 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13002 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13003 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13004
13005 uint bitmap_bits;
13006 uint bitmap_nums;
13007 uint bitmap_mask;
13008 uint bitmap_size;
13009
13010 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13011 {
13012 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13013
13014 bitmap_nums = 1 << bitmap_bits;
13015
13016 bitmap_mask = bitmap_nums - 1;
13017
13018 bitmap_size = bitmap_nums * sizeof (uint);
13019
13020 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13021
13022 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;
13023 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;
13024
13025 break;
13026 }
13027
13028 bitmap_nums = 1 << bitmap_bits;
13029
13030 bitmap_mask = bitmap_nums - 1;
13031
13032 bitmap_size = bitmap_nums * sizeof (uint);
13033
13034 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);
13035 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);
13036
13037 /**
13038 * prepare quick rule
13039 */
13040
13041 data.rule_buf_l = rule_buf_l;
13042 data.rule_buf_r = rule_buf_r;
13043
13044 int rule_len_l = (int) strlen (rule_buf_l);
13045 int rule_len_r = (int) strlen (rule_buf_r);
13046
13047 data.rule_len_l = rule_len_l;
13048 data.rule_len_r = rule_len_r;
13049
13050 /**
13051 * load rules
13052 */
13053
13054 uint *all_kernel_rules_cnt = NULL;
13055
13056 kernel_rule_t **all_kernel_rules_buf = NULL;
13057
13058 if (rp_files_cnt)
13059 {
13060 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13061
13062 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13063 }
13064
13065 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13066
13067 int rule_len = 0;
13068
13069 for (uint i = 0; i < rp_files_cnt; i++)
13070 {
13071 uint kernel_rules_avail = 0;
13072
13073 uint kernel_rules_cnt = 0;
13074
13075 kernel_rule_t *kernel_rules_buf = NULL;
13076
13077 char *rp_file = rp_files[i];
13078
13079 char in[BLOCK_SIZE] = { 0 };
13080 char out[BLOCK_SIZE] = { 0 };
13081
13082 FILE *fp = NULL;
13083
13084 uint rule_line = 0;
13085
13086 if ((fp = fopen (rp_file, "rb")) == NULL)
13087 {
13088 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13089
13090 return (-1);
13091 }
13092
13093 while (!feof (fp))
13094 {
13095 memset (rule_buf, 0, HCBUFSIZ);
13096
13097 rule_len = fgetl (fp, rule_buf);
13098
13099 rule_line++;
13100
13101 if (rule_len == 0) continue;
13102
13103 if (rule_buf[0] == '#') continue;
13104
13105 if (kernel_rules_avail == kernel_rules_cnt)
13106 {
13107 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13108
13109 kernel_rules_avail += INCR_RULES;
13110 }
13111
13112 memset (in, 0, BLOCK_SIZE);
13113 memset (out, 0, BLOCK_SIZE);
13114
13115 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13116
13117 if (result == -1)
13118 {
13119 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13120
13121 continue;
13122 }
13123
13124 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13125 {
13126 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13127
13128 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13129
13130 continue;
13131 }
13132
13133 /* its so slow
13134 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13135 {
13136 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13137
13138 continue;
13139 }
13140 */
13141
13142 kernel_rules_cnt++;
13143 }
13144
13145 fclose (fp);
13146
13147 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13148
13149 all_kernel_rules_buf[i] = kernel_rules_buf;
13150 }
13151
13152 /**
13153 * merge rules or automatic rule generator
13154 */
13155
13156 uint kernel_rules_cnt = 0;
13157
13158 kernel_rule_t *kernel_rules_buf = NULL;
13159
13160 if (attack_mode == ATTACK_MODE_STRAIGHT)
13161 {
13162 if (rp_files_cnt)
13163 {
13164 kernel_rules_cnt = 1;
13165
13166 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13167
13168 repeats[0] = kernel_rules_cnt;
13169
13170 for (uint i = 0; i < rp_files_cnt; i++)
13171 {
13172 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13173
13174 repeats[i + 1] = kernel_rules_cnt;
13175 }
13176
13177 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13178
13179 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13180
13181 for (uint i = 0; i < kernel_rules_cnt; i++)
13182 {
13183 uint out_pos = 0;
13184
13185 kernel_rule_t *out = &kernel_rules_buf[i];
13186
13187 for (uint j = 0; j < rp_files_cnt; j++)
13188 {
13189 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13190 uint in_pos;
13191
13192 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13193
13194 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13195 {
13196 if (out_pos == RULES_MAX - 1)
13197 {
13198 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13199
13200 break;
13201 }
13202
13203 out->cmds[out_pos] = in->cmds[in_pos];
13204 }
13205 }
13206 }
13207
13208 local_free (repeats);
13209 }
13210 else if (rp_gen)
13211 {
13212 uint kernel_rules_avail = 0;
13213
13214 while (kernel_rules_cnt < rp_gen)
13215 {
13216 if (kernel_rules_avail == kernel_rules_cnt)
13217 {
13218 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13219
13220 kernel_rules_avail += INCR_RULES;
13221 }
13222
13223 memset (rule_buf, 0, HCBUFSIZ);
13224
13225 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13226
13227 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13228
13229 kernel_rules_cnt++;
13230 }
13231 }
13232 }
13233
13234 myfree (rule_buf);
13235
13236 /**
13237 * generate NOP rules
13238 */
13239
13240 if (kernel_rules_cnt == 0)
13241 {
13242 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13243
13244 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13245
13246 kernel_rules_cnt++;
13247 }
13248
13249 data.kernel_rules_cnt = kernel_rules_cnt;
13250 data.kernel_rules_buf = kernel_rules_buf;
13251
13252 /**
13253 * OpenCL platforms: detect
13254 */
13255
13256 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13257 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13258
13259 cl_uint platforms_cnt = 0;
13260 cl_uint platform_devices_cnt = 0;
13261
13262 if (keyspace == 0)
13263 {
13264 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13265
13266 if (platforms_cnt == 0)
13267 {
13268 log_info ("");
13269 log_info ("ATTENTION! No OpenCL compatible platform found");
13270 log_info ("");
13271 log_info ("You're probably missing the OpenCL runtime installation");
13272 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13273 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13274 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13275 log_info ("");
13276
13277 return (-1);
13278 }
13279
13280 if (opencl_platforms_filter != (uint) -1)
13281 {
13282 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13283
13284 if (opencl_platforms_filter > platform_cnt_mask)
13285 {
13286 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13287
13288 return (-1);
13289 }
13290 }
13291 }
13292
13293 /**
13294 * OpenCL device types:
13295 * 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.
13296 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13297 */
13298
13299 if (opencl_device_types == NULL)
13300 {
13301 cl_device_type device_types_all = 0;
13302
13303 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13304 {
13305 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13306
13307 cl_platform_id platform = platforms[platform_id];
13308
13309 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13310
13311 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13312 {
13313 cl_device_id device = platform_devices[platform_devices_id];
13314
13315 cl_device_type device_type;
13316
13317 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13318
13319 device_types_all |= device_type;
13320 }
13321 }
13322
13323 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13324 {
13325 device_types_filter |= CL_DEVICE_TYPE_CPU;
13326 }
13327 }
13328
13329 /**
13330 * OpenCL devices: simply push all devices from all platforms into the same device array
13331 */
13332
13333 int need_adl = 0;
13334 int need_nvapi = 0;
13335 int need_nvml = 0;
13336
13337 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13338
13339 data.devices_param = devices_param;
13340
13341 uint devices_cnt = 0;
13342
13343 uint devices_active = 0;
13344
13345 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13346 {
13347 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13348
13349 cl_platform_id platform = platforms[platform_id];
13350
13351 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13352
13353 char platform_vendor[INFOSZ] = { 0 };
13354
13355 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13356
13357 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13358 // this causes trouble with vendor id based macros
13359 // we'll assign generic to those without special optimization available
13360
13361 cl_uint platform_vendor_id = 0;
13362
13363 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_AMD;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_APPLE;
13374 }
13375 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13376 {
13377 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13378 }
13379 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13380 {
13381 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13382 }
13383 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13384 {
13385 platform_vendor_id = VENDOR_ID_MESA;
13386 }
13387 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13388 {
13389 platform_vendor_id = VENDOR_ID_NV;
13390 }
13391 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13392 {
13393 platform_vendor_id = VENDOR_ID_POCL;
13394 }
13395 else
13396 {
13397 platform_vendor_id = VENDOR_ID_GENERIC;
13398 }
13399
13400 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13401 {
13402 size_t param_value_size = 0;
13403
13404 const uint device_id = devices_cnt;
13405
13406 hc_device_param_t *device_param = &data.devices_param[device_id];
13407
13408 device_param->platform_vendor_id = platform_vendor_id;
13409
13410 device_param->device = platform_devices[platform_devices_id];
13411
13412 device_param->device_id = device_id;
13413
13414 device_param->platform_devices_id = platform_devices_id;
13415
13416 // device_type
13417
13418 cl_device_type device_type;
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13421
13422 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13423
13424 device_param->device_type = device_type;
13425
13426 // device_name
13427
13428 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13429
13430 char *device_name = (char *) mymalloc (param_value_size);
13431
13432 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13433
13434 device_param->device_name = device_name;
13435
13436 // device_vendor
13437
13438 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13439
13440 char *device_vendor = (char *) mymalloc (param_value_size);
13441
13442 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13443
13444 device_param->device_vendor = device_vendor;
13445
13446 cl_uint device_vendor_id = 0;
13447
13448 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_AMD;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_APPLE;
13459 }
13460 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13461 {
13462 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13463 }
13464 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13465 {
13466 device_vendor_id = VENDOR_ID_INTEL_SDK;
13467 }
13468 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13469 {
13470 device_vendor_id = VENDOR_ID_MESA;
13471 }
13472 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13473 {
13474 device_vendor_id = VENDOR_ID_NV;
13475 }
13476 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13477 {
13478 device_vendor_id = VENDOR_ID_POCL;
13479 }
13480 else
13481 {
13482 device_vendor_id = VENDOR_ID_GENERIC;
13483 }
13484
13485 device_param->device_vendor_id = device_vendor_id;
13486
13487 // tuning db
13488
13489 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13490
13491 // device_version
13492
13493 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13494
13495 char *device_version = (char *) mymalloc (param_value_size);
13496
13497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13498
13499 device_param->device_version = device_version;
13500
13501 // device_opencl_version
13502
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13504
13505 char *device_opencl_version = (char *) mymalloc (param_value_size);
13506
13507 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13508
13509 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13510
13511 myfree (device_opencl_version);
13512
13513 // vector_width
13514
13515 cl_uint vector_width;
13516
13517 if (opencl_vector_width_chgd == 0)
13518 {
13519 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13520 {
13521 if (opti_type & OPTI_TYPE_USES_BITS_64)
13522 {
13523 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13524 }
13525 else
13526 {
13527 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13528 }
13529 }
13530 else
13531 {
13532 vector_width = (cl_uint) tuningdb_entry->vector_width;
13533 }
13534 }
13535 else
13536 {
13537 vector_width = opencl_vector_width;
13538 }
13539
13540 if (vector_width > 16) vector_width = 16;
13541
13542 device_param->vector_width = vector_width;
13543
13544 // max_compute_units
13545
13546 cl_uint device_processors;
13547
13548 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13549
13550 device_param->device_processors = device_processors;
13551
13552 // device_maxmem_alloc
13553 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13554
13555 cl_ulong device_maxmem_alloc;
13556
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13558
13559 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13560
13561 // device_global_mem
13562
13563 cl_ulong device_global_mem;
13564
13565 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13566
13567 device_param->device_global_mem = device_global_mem;
13568
13569 // max_work_group_size
13570
13571 size_t device_maxworkgroup_size;
13572
13573 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13574
13575 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13576
13577 // max_clock_frequency
13578
13579 cl_uint device_maxclock_frequency;
13580
13581 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13582
13583 device_param->device_maxclock_frequency = device_maxclock_frequency;
13584
13585 // device_endian_little
13586
13587 cl_bool device_endian_little;
13588
13589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13590
13591 if (device_endian_little == CL_FALSE)
13592 {
13593 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13594
13595 device_param->skipped = 1;
13596 }
13597
13598 // device_available
13599
13600 cl_bool device_available;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13603
13604 if (device_available == CL_FALSE)
13605 {
13606 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13607
13608 device_param->skipped = 1;
13609 }
13610
13611 // device_compiler_available
13612
13613 cl_bool device_compiler_available;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13616
13617 if (device_compiler_available == CL_FALSE)
13618 {
13619 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13620
13621 device_param->skipped = 1;
13622 }
13623
13624 // device_execution_capabilities
13625
13626 cl_device_exec_capabilities device_execution_capabilities;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13629
13630 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13631 {
13632 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13633
13634 device_param->skipped = 1;
13635 }
13636
13637 // device_extensions
13638
13639 size_t device_extensions_size;
13640
13641 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13642
13643 char *device_extensions = mymalloc (device_extensions_size + 1);
13644
13645 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13646
13647 if (strstr (device_extensions, "base_atomics") == 0)
13648 {
13649 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13650
13651 device_param->skipped = 1;
13652 }
13653
13654 if (strstr (device_extensions, "byte_addressable_store") == 0)
13655 {
13656 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13657
13658 device_param->skipped = 1;
13659 }
13660
13661 myfree (device_extensions);
13662
13663 // device_local_mem_size
13664
13665 cl_ulong device_local_mem_size;
13666
13667 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13668
13669 if (device_local_mem_size < 32768)
13670 {
13671 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13672
13673 device_param->skipped = 1;
13674 }
13675
13676 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13677 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13678 // This results in both utilizing it for 50%
13679 // However, Intel has much better SIMD control over their own hardware
13680 // It makes sense to give them full control over their own hardware
13681
13682 if (device_type & CL_DEVICE_TYPE_CPU)
13683 {
13684 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13685 {
13686 if (data.force == 0)
13687 {
13688 if (algorithm_pos == 0)
13689 {
13690 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13691 log_info (" You can use --force to override this but do not post error reports if you do so");
13692 }
13693
13694 device_param->skipped = 1;
13695 }
13696 }
13697 }
13698
13699 // skipped
13700
13701 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13702 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13703
13704 // driver_version
13705
13706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13707
13708 char *driver_version = (char *) mymalloc (param_value_size);
13709
13710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13711
13712 device_param->driver_version = driver_version;
13713
13714 // device_name_chksum
13715
13716 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13717
13718 #if __x86_64__
13719 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);
13720 #else
13721 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);
13722 #endif
13723
13724 uint device_name_digest[4] = { 0 };
13725
13726 md5_64 ((uint *) device_name_chksum, device_name_digest);
13727
13728 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13729
13730 device_param->device_name_chksum = device_name_chksum;
13731
13732 // device_processor_cores
13733
13734 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13735 {
13736 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13737 {
13738 need_adl = 1;
13739 }
13740
13741 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13742 {
13743 need_nvml = 1;
13744
13745 #ifdef _WIN
13746 need_nvapi = 1;
13747 #endif
13748 }
13749 }
13750
13751 // device_processor_cores
13752
13753 if (device_type & CL_DEVICE_TYPE_CPU)
13754 {
13755 cl_uint device_processor_cores = 1;
13756
13757 device_param->device_processor_cores = device_processor_cores;
13758 }
13759
13760 if (device_type & CL_DEVICE_TYPE_GPU)
13761 {
13762 if (device_vendor_id == VENDOR_ID_AMD)
13763 {
13764 cl_uint device_processor_cores = 0;
13765
13766 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13767
13768 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13769
13770 device_param->device_processor_cores = device_processor_cores;
13771 }
13772 else if (device_vendor_id == VENDOR_ID_NV)
13773 {
13774 cl_uint kernel_exec_timeout = 0;
13775
13776 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13777
13778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13779
13780 device_param->kernel_exec_timeout = kernel_exec_timeout;
13781
13782 cl_uint device_processor_cores = 0;
13783
13784 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13785
13786 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13787
13788 device_param->device_processor_cores = device_processor_cores;
13789
13790 cl_uint sm_minor = 0;
13791 cl_uint sm_major = 0;
13792
13793 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13794 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13795
13796 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13798
13799 device_param->sm_minor = sm_minor;
13800 device_param->sm_major = sm_major;
13801 }
13802 else
13803 {
13804 cl_uint device_processor_cores = 1;
13805
13806 device_param->device_processor_cores = device_processor_cores;
13807 }
13808 }
13809
13810 // display results
13811
13812 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13813 {
13814 if (machine_readable == 0)
13815 {
13816 if (device_param->skipped == 0)
13817 {
13818 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13819 device_id + 1,
13820 device_name,
13821 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13822 (unsigned int) (device_global_mem / 1024 / 1024),
13823 (unsigned int) device_processors);
13824 }
13825 else
13826 {
13827 log_info ("Device #%u: %s, skipped",
13828 device_id + 1,
13829 device_name);
13830 }
13831 }
13832 }
13833
13834 // common driver check
13835
13836 if (device_param->skipped == 0)
13837 {
13838 if (device_type & CL_DEVICE_TYPE_GPU)
13839 {
13840 if (platform_vendor_id == VENDOR_ID_AMD)
13841 {
13842 int catalyst_check = (force == 1) ? 0 : 1;
13843
13844 int catalyst_warn = 0;
13845
13846 int catalyst_broken = 0;
13847
13848 if (catalyst_check == 1)
13849 {
13850 catalyst_warn = 1;
13851
13852 // v14.9 and higher
13853 if (atoi (device_param->driver_version) >= 1573)
13854 {
13855 catalyst_warn = 0;
13856 }
13857
13858 catalyst_check = 0;
13859 }
13860
13861 if (catalyst_broken == 1)
13862 {
13863 log_info ("");
13864 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13865 log_info ("It will pass over cracked hashes and does not report them as cracked");
13866 log_info ("You are STRONGLY encouraged not to use it");
13867 log_info ("You can use --force to override this but do not post error reports if you do so");
13868 log_info ("");
13869
13870 return (-1);
13871 }
13872
13873 if (catalyst_warn == 1)
13874 {
13875 log_info ("");
13876 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13877 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13878 log_info ("See hashcat's homepage for official supported catalyst drivers");
13879 #ifdef _WIN
13880 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13881 #endif
13882 log_info ("You can use --force to override this but do not post error reports if you do so");
13883 log_info ("");
13884
13885 return (-1);
13886 }
13887 }
13888 else if (platform_vendor_id == VENDOR_ID_NV)
13889 {
13890 if (device_param->kernel_exec_timeout != 0)
13891 {
13892 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);
13893 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13894 }
13895 }
13896 }
13897
13898 /* turns out pocl still creates segfaults (because of llvm)
13899 if (device_type & CL_DEVICE_TYPE_CPU)
13900 {
13901 if (platform_vendor_id == VENDOR_ID_AMD)
13902 {
13903 if (force == 0)
13904 {
13905 log_info ("");
13906 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13907 log_info ("You are STRONGLY encouraged not to use it");
13908 log_info ("You can use --force to override this but do not post error reports if you do so");
13909 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13910 log_info ("");
13911
13912 return (-1);
13913 }
13914 }
13915 }
13916 */
13917
13918 /**
13919 * kernel accel and loops tuning db adjustment
13920 */
13921
13922 device_param->kernel_accel_min = 1;
13923 device_param->kernel_accel_max = 1024;
13924
13925 device_param->kernel_loops_min = 1;
13926 device_param->kernel_loops_max = 1024;
13927
13928 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13929
13930 if (tuningdb_entry)
13931 {
13932 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13933 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13934
13935 if (_kernel_accel)
13936 {
13937 device_param->kernel_accel_min = _kernel_accel;
13938 device_param->kernel_accel_max = _kernel_accel;
13939 }
13940
13941 if (_kernel_loops)
13942 {
13943 if (workload_profile == 1)
13944 {
13945 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13946 }
13947 else if (workload_profile == 2)
13948 {
13949 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13950 }
13951
13952 device_param->kernel_loops_min = _kernel_loops;
13953 device_param->kernel_loops_max = _kernel_loops;
13954 }
13955 }
13956
13957 // commandline parameters overwrite tuningdb entries
13958
13959 if (kernel_accel)
13960 {
13961 device_param->kernel_accel_min = kernel_accel;
13962 device_param->kernel_accel_max = kernel_accel;
13963 }
13964
13965 if (kernel_loops)
13966 {
13967 device_param->kernel_loops_min = kernel_loops;
13968 device_param->kernel_loops_max = kernel_loops;
13969 }
13970
13971 /**
13972 * activate device
13973 */
13974
13975 devices_active++;
13976 }
13977
13978 // next please
13979
13980 devices_cnt++;
13981 }
13982 }
13983
13984 if (keyspace == 0 && devices_active == 0)
13985 {
13986 log_error ("ERROR: No devices found/left");
13987
13988 return (-1);
13989 }
13990
13991 // 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)
13992
13993 if (devices_filter != (uint) -1)
13994 {
13995 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13996
13997 if (devices_filter > devices_cnt_mask)
13998 {
13999 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14000
14001 return (-1);
14002 }
14003 }
14004
14005 data.devices_cnt = devices_cnt;
14006
14007 data.devices_active = devices_active;
14008
14009 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14010 {
14011 if (machine_readable == 0)
14012 {
14013 log_info ("");
14014 }
14015 }
14016
14017 /**
14018 * HM devices: init
14019 */
14020
14021 #ifdef HAVE_HWMON
14022 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14023 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14024 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14025
14026 if (gpu_temp_disable == 0)
14027 {
14028 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14029 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14030 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14031
14032 data.hm_adl = NULL;
14033 data.hm_nvapi = NULL;
14034 data.hm_nvml = NULL;
14035
14036 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14037 {
14038 data.hm_nvml = nvml;
14039 }
14040
14041 if (data.hm_nvml)
14042 {
14043 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14044 {
14045 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14046
14047 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14048
14049 int tmp_out = 0;
14050
14051 for (int i = 0; i < tmp_in; i++)
14052 {
14053 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14054 }
14055
14056 for (int i = 0; i < tmp_out; i++)
14057 {
14058 unsigned int speed;
14059
14060 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14061
14062 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14063
14064 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14065 }
14066 }
14067 }
14068
14069 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14070 {
14071 data.hm_nvapi = nvapi;
14072 }
14073
14074 if (data.hm_nvapi)
14075 {
14076 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14077 {
14078 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14079
14080 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14081
14082 int tmp_out = 0;
14083
14084 for (int i = 0; i < tmp_in; i++)
14085 {
14086 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14087 }
14088 }
14089 }
14090
14091 if ((need_adl == 1) && (adl_init (adl) == 0))
14092 {
14093 data.hm_adl = adl;
14094 }
14095
14096 if (data.hm_adl)
14097 {
14098 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14099 {
14100 // total number of adapters
14101
14102 int hm_adapters_num;
14103
14104 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14105
14106 // adapter info
14107
14108 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14109
14110 if (lpAdapterInfo == NULL) return (-1);
14111
14112 // get a list (of ids of) valid/usable adapters
14113
14114 int num_adl_adapters = 0;
14115
14116 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14117
14118 if (num_adl_adapters > 0)
14119 {
14120 hc_thread_mutex_lock (mux_adl);
14121
14122 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14123
14124 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14125
14126 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14127 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14128
14129 hc_thread_mutex_unlock (mux_adl);
14130 }
14131
14132 myfree (valid_adl_device_list);
14133 myfree (lpAdapterInfo);
14134 }
14135 }
14136
14137 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14138 {
14139 gpu_temp_disable = 1;
14140 }
14141 }
14142
14143 /**
14144 * OpenCL devices: allocate buffer for device specific information
14145 */
14146
14147 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14148 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14149
14150 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14151
14152 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14153
14154 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14155
14156 /**
14157 * User-defined GPU temp handling
14158 */
14159
14160 if (gpu_temp_disable == 1)
14161 {
14162 gpu_temp_abort = 0;
14163 gpu_temp_retain = 0;
14164 }
14165
14166 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14167 {
14168 if (gpu_temp_abort < gpu_temp_retain)
14169 {
14170 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14171
14172 return (-1);
14173 }
14174 }
14175
14176 data.gpu_temp_disable = gpu_temp_disable;
14177 data.gpu_temp_abort = gpu_temp_abort;
14178 data.gpu_temp_retain = gpu_temp_retain;
14179 #endif
14180
14181 /**
14182 * enable custom signal handler(s)
14183 */
14184
14185 if (benchmark == 0)
14186 {
14187 hc_signal (sigHandler_default);
14188 }
14189 else
14190 {
14191 hc_signal (sigHandler_benchmark);
14192 }
14193
14194 /**
14195 * inform the user
14196 */
14197
14198 if (data.quiet == 0)
14199 {
14200 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14201
14202 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);
14203
14204 if (attack_mode == ATTACK_MODE_STRAIGHT)
14205 {
14206 log_info ("Rules: %u", kernel_rules_cnt);
14207 }
14208
14209 if (opti_type)
14210 {
14211 log_info ("Applicable Optimizers:");
14212
14213 for (uint i = 0; i < 32; i++)
14214 {
14215 const uint opti_bit = 1u << i;
14216
14217 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14218 }
14219 }
14220
14221 /**
14222 * Watchdog and Temperature balance
14223 */
14224
14225 #ifdef HAVE_HWMON
14226 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14227 {
14228 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14229 }
14230
14231 if (gpu_temp_abort == 0)
14232 {
14233 log_info ("Watchdog: Temperature abort trigger disabled");
14234 }
14235 else
14236 {
14237 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14238 }
14239
14240 if (gpu_temp_retain == 0)
14241 {
14242 log_info ("Watchdog: Temperature retain trigger disabled");
14243 }
14244 else
14245 {
14246 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14247 }
14248
14249 if (data.quiet == 0) log_info ("");
14250 #endif
14251 }
14252
14253 #ifdef HAVE_HWMON
14254
14255 /**
14256 * HM devices: copy
14257 */
14258
14259 if (gpu_temp_disable == 0)
14260 {
14261 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14262 {
14263 hc_device_param_t *device_param = &data.devices_param[device_id];
14264
14265 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14266
14267 if (device_param->skipped) continue;
14268
14269 const uint platform_devices_id = device_param->platform_devices_id;
14270
14271 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14272 {
14273 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14274 data.hm_device[device_id].nvapi = 0;
14275 data.hm_device[device_id].nvml = 0;
14276 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14277 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14278 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14279 }
14280
14281 if (device_param->device_vendor_id == VENDOR_ID_NV)
14282 {
14283 data.hm_device[device_id].adl = 0;
14284 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14285 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14286 data.hm_device[device_id].od_version = 0;
14287 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14288 data.hm_device[device_id].fan_set_supported = 0;
14289 }
14290 }
14291 }
14292
14293 /**
14294 * powertune on user request
14295 */
14296
14297 if (powertune_enable == 1)
14298 {
14299 hc_thread_mutex_lock (mux_adl);
14300
14301 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14302 {
14303 hc_device_param_t *device_param = &data.devices_param[device_id];
14304
14305 if (device_param->skipped) continue;
14306
14307 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14308 {
14309 /**
14310 * Temporary fix:
14311 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14312 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14313 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14314 * Driver / ADL bug?
14315 */
14316
14317 if (data.hm_device[device_id].od_version == 6)
14318 {
14319 int ADL_rc;
14320
14321 // check powertune capabilities first, if not available then skip device
14322
14323 int powertune_supported = 0;
14324
14325 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14326 {
14327 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14328
14329 return (-1);
14330 }
14331
14332 // first backup current value, we will restore it later
14333
14334 if (powertune_supported != 0)
14335 {
14336 // powercontrol settings
14337
14338 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14339
14340 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14341 {
14342 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14343 }
14344
14345 if (ADL_rc != ADL_OK)
14346 {
14347 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14348
14349 return (-1);
14350 }
14351
14352 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14353 {
14354 log_error ("ERROR: Failed to set new ADL PowerControl values");
14355
14356 return (-1);
14357 }
14358
14359 // clocks
14360
14361 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14362
14363 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14364
14365 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14366 {
14367 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14368
14369 return (-1);
14370 }
14371
14372 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14373
14374 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14375
14376 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14377 {
14378 log_error ("ERROR: Failed to get ADL device capabilities");
14379
14380 return (-1);
14381 }
14382
14383 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14384 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14385
14386 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14387 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14388
14389 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14390 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14391
14392 // warning if profile has too low max values
14393
14394 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14395 {
14396 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14397 }
14398
14399 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14400 {
14401 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14402 }
14403
14404 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14405
14406 performance_state->iNumberOfPerformanceLevels = 2;
14407
14408 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14409 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14410 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14411 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14412
14413 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14414 {
14415 log_info ("ERROR: Failed to set ADL performance state");
14416
14417 return (-1);
14418 }
14419
14420 local_free (performance_state);
14421 }
14422
14423 // set powertune value only
14424
14425 if (powertune_supported != 0)
14426 {
14427 // powertune set
14428 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14429
14430 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14431 {
14432 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14433
14434 return (-1);
14435 }
14436
14437 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14438 {
14439 log_error ("ERROR: Failed to set new ADL PowerControl values");
14440
14441 return (-1);
14442 }
14443 }
14444 }
14445 }
14446
14447 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14448 {
14449 // first backup current value, we will restore it later
14450
14451 unsigned int limit;
14452
14453 int powertune_supported = 0;
14454
14455 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14456 {
14457 powertune_supported = 1;
14458 }
14459
14460 // if backup worked, activate the maximum allowed
14461
14462 if (powertune_supported != 0)
14463 {
14464 unsigned int minLimit;
14465 unsigned int maxLimit;
14466
14467 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14468 {
14469 if (maxLimit > 0)
14470 {
14471 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14472 {
14473 // now we can be sure we need to reset later
14474
14475 nvml_power_limit[device_id] = limit;
14476 }
14477 }
14478 }
14479 }
14480 }
14481 }
14482
14483 hc_thread_mutex_unlock (mux_adl);
14484 }
14485
14486 #endif // HAVE_HWMON
14487
14488 #ifdef DEBUG
14489 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14490 #endif
14491
14492 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14493
14494 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14495 {
14496 /**
14497 * host buffer
14498 */
14499
14500 hc_device_param_t *device_param = &data.devices_param[device_id];
14501
14502 if (device_param->skipped) continue;
14503
14504 /**
14505 * device properties
14506 */
14507
14508 const char *device_name_chksum = device_param->device_name_chksum;
14509 const u32 device_processors = device_param->device_processors;
14510 const u32 device_processor_cores = device_param->device_processor_cores;
14511
14512 /**
14513 * create context for each device
14514 */
14515
14516 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14517
14518 /**
14519 * create command-queue
14520 */
14521
14522 // not supported with NV
14523 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14524
14525 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14526
14527 /**
14528 * kernel threads: some algorithms need a fixed kernel-threads count
14529 * because of shared memory usage or bitslice
14530 * there needs to be some upper limit, otherwise there's too much overhead
14531 */
14532
14533 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14534
14535 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14536 {
14537 kernel_threads = KERNEL_THREADS_MAX_CPU;
14538 }
14539
14540 if (hash_mode == 1500) kernel_threads = 64; // DES
14541 if (hash_mode == 3000) kernel_threads = 64; // DES
14542 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14543 if (hash_mode == 7500) kernel_threads = 64; // RC4
14544 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14545 if (hash_mode == 9700) kernel_threads = 64; // RC4
14546 if (hash_mode == 9710) kernel_threads = 64; // RC4
14547 if (hash_mode == 9800) kernel_threads = 64; // RC4
14548 if (hash_mode == 9810) kernel_threads = 64; // RC4
14549 if (hash_mode == 10400) kernel_threads = 64; // RC4
14550 if (hash_mode == 10410) kernel_threads = 64; // RC4
14551 if (hash_mode == 10500) kernel_threads = 64; // RC4
14552 if (hash_mode == 13100) kernel_threads = 64; // RC4
14553
14554 device_param->kernel_threads = kernel_threads;
14555
14556 /**
14557 * create input buffers on device : calculate size of fixed memory buffers
14558 */
14559
14560 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14561 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14562
14563 device_param->size_root_css = size_root_css;
14564 device_param->size_markov_css = size_markov_css;
14565
14566 size_t size_results = sizeof (uint);
14567
14568 device_param->size_results = size_results;
14569
14570 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14571 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14572
14573 size_t size_plains = digests_cnt * sizeof (plain_t);
14574 size_t size_salts = salts_cnt * sizeof (salt_t);
14575 size_t size_esalts = salts_cnt * esalt_size;
14576
14577 device_param->size_plains = size_plains;
14578 device_param->size_digests = size_digests;
14579 device_param->size_shown = size_shown;
14580 device_param->size_salts = size_salts;
14581
14582 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14583 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14584 size_t size_tm = 32 * sizeof (bs_word_t);
14585
14586 // scryptV stuff
14587
14588 size_t size_scryptV = 1;
14589
14590 if ((hash_mode == 8900) || (hash_mode == 9300))
14591 {
14592 uint tmto_start = 0;
14593 uint tmto_stop = 10;
14594
14595 if (scrypt_tmto)
14596 {
14597 tmto_start = scrypt_tmto;
14598 }
14599 else
14600 {
14601 // in case the user did not specify the tmto manually
14602 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14603 // but set the lower end only in case the user has a device with too less memory
14604
14605 if (hash_mode == 8900)
14606 {
14607 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14608 {
14609 tmto_start = 1;
14610 }
14611 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14612 {
14613 tmto_start = 2;
14614 }
14615 }
14616 else if (hash_mode == 9300)
14617 {
14618 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14619 {
14620 tmto_start = 2;
14621 }
14622 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14623 {
14624 tmto_start = 2;
14625 }
14626 }
14627 }
14628
14629 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14630 {
14631 // TODO: in theory the following calculation needs to be done per salt, not global
14632 // we assume all hashes have the same scrypt settings
14633
14634 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14635
14636 size_scryptV /= 1 << tmto;
14637
14638 size_scryptV *= device_processors * device_processor_cores;
14639
14640 if (size_scryptV > device_param->device_maxmem_alloc)
14641 {
14642 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14643
14644 continue;
14645 }
14646
14647 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14648 {
14649 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14650 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14651 }
14652
14653 break;
14654 }
14655
14656 if (data.salts_buf[0].scrypt_phy == 0)
14657 {
14658 log_error ("ERROR: can't allocate enough device memory");
14659
14660 return -1;
14661 }
14662
14663 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14664 }
14665
14666 /**
14667 * some algorithms need a fixed kernel-loops count
14668 */
14669
14670 if (hash_mode == 1500)
14671 {
14672 const u32 kernel_loops_fixed = 1024;
14673
14674 device_param->kernel_loops_min = kernel_loops_fixed;
14675 device_param->kernel_loops_max = kernel_loops_fixed;
14676 }
14677
14678 if (hash_mode == 3000)
14679 {
14680 const u32 kernel_loops_fixed = 1024;
14681
14682 device_param->kernel_loops_min = kernel_loops_fixed;
14683 device_param->kernel_loops_max = kernel_loops_fixed;
14684 }
14685
14686 if (hash_mode == 8900)
14687 {
14688 const u32 kernel_loops_fixed = 1;
14689
14690 device_param->kernel_loops_min = kernel_loops_fixed;
14691 device_param->kernel_loops_max = kernel_loops_fixed;
14692 }
14693
14694 if (hash_mode == 9300)
14695 {
14696 const u32 kernel_loops_fixed = 1;
14697
14698 device_param->kernel_loops_min = kernel_loops_fixed;
14699 device_param->kernel_loops_max = kernel_loops_fixed;
14700 }
14701
14702 if (hash_mode == 12500)
14703 {
14704 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14705
14706 device_param->kernel_loops_min = kernel_loops_fixed;
14707 device_param->kernel_loops_max = kernel_loops_fixed;
14708 }
14709
14710 /**
14711 * some algorithms have a maximum kernel-loops count
14712 */
14713
14714 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14715 {
14716 u32 innerloop_cnt = 0;
14717
14718 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14719 {
14720 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14721 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14722 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14723 }
14724 else
14725 {
14726 innerloop_cnt = data.salts_buf[0].salt_iter;
14727 }
14728
14729 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14730 (innerloop_cnt <= device_param->kernel_loops_max))
14731 {
14732 device_param->kernel_loops_max = innerloop_cnt;
14733 }
14734 }
14735
14736 u32 kernel_accel_min = device_param->kernel_accel_min;
14737 u32 kernel_accel_max = device_param->kernel_accel_max;
14738
14739 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14740
14741 size_t size_pws = 4;
14742 size_t size_tmps = 4;
14743 size_t size_hooks = 4;
14744
14745 while (kernel_accel_max >= kernel_accel_min)
14746 {
14747 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14748
14749 // size_pws
14750
14751 size_pws = kernel_power_max * sizeof (pw_t);
14752
14753 // size_tmps
14754
14755 switch (hash_mode)
14756 {
14757 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14758 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14759 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14760 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14761 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14762 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14763 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14764 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14765 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14766 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14767 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14768 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14769 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14770 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14771 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14772 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14773 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14774 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14775 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14776 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14777 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14778 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14779 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14780 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14781 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14782 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14783 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14784 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14785 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14786 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14787 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14788 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14789 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14790 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14791 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14792 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14793 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14794 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14795 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14796 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14797 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14798 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14799 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14800 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14801 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14802 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14803 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14804 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14805 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14806 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14807 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14808 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14809 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14810 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14811 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14812 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14813 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14814 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14815 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14816 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14817 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14818 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14819 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14820 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14821 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14822 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14823 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14824 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14825 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14826 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14827 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14828 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14829 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14830 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14831 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14832 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14833 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14834 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14835 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14836 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14837 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14838 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14839 };
14840
14841 // size_hooks
14842
14843 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14844 {
14845 // none yet
14846 }
14847
14848 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14849 // if not, decrease amplifier and try again
14850
14851 int skip = 0;
14852
14853 const u64 size_total
14854 = bitmap_size
14855 + bitmap_size
14856 + bitmap_size
14857 + bitmap_size
14858 + bitmap_size
14859 + bitmap_size
14860 + bitmap_size
14861 + bitmap_size
14862 + size_bfs
14863 + size_combs
14864 + size_digests
14865 + size_esalts
14866 + size_hooks
14867 + size_markov_css
14868 + size_plains
14869 + size_pws
14870 + size_pws // not a bug
14871 + size_results
14872 + size_root_css
14873 + size_rules
14874 + size_rules_c
14875 + size_salts
14876 + size_scryptV
14877 + size_shown
14878 + size_tm
14879 + size_tmps;
14880
14881 // Don't ask me, ask AMD!
14882
14883 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14884 if (size_total > device_param->device_global_mem) skip = 1;
14885
14886 if (skip == 1)
14887 {
14888 kernel_accel_max--;
14889
14890 continue;
14891 }
14892
14893 break;
14894 }
14895
14896 /*
14897 if (kernel_accel_max == 0)
14898 {
14899 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14900
14901 return -1;
14902 }
14903 */
14904
14905 device_param->kernel_accel_min = kernel_accel_min;
14906 device_param->kernel_accel_max = kernel_accel_max;
14907
14908 /*
14909 if (kernel_accel_max < kernel_accel)
14910 {
14911 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14912
14913 device_param->kernel_accel = kernel_accel_max;
14914 }
14915 */
14916
14917 device_param->size_bfs = size_bfs;
14918 device_param->size_combs = size_combs;
14919 device_param->size_rules = size_rules;
14920 device_param->size_rules_c = size_rules_c;
14921 device_param->size_pws = size_pws;
14922 device_param->size_tmps = size_tmps;
14923 device_param->size_hooks = size_hooks;
14924
14925 /**
14926 * default building options
14927 */
14928
14929 char build_opts[1024] = { 0 };
14930
14931 // we don't have sm_* on vendors not NV but it doesn't matter
14932
14933 #if _WIN
14934 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);
14935 #else
14936 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);
14937 #endif
14938
14939 char build_opts_new[1024] = { 0 };
14940
14941 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);
14942
14943 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14944
14945 /*
14946 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14947 {
14948 // we do vectorizing much better than the auto-vectorizer
14949
14950 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14951
14952 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14953 }
14954 */
14955
14956 #ifdef DEBUG
14957 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14958 #endif
14959
14960 /**
14961 * main kernel
14962 */
14963
14964 {
14965 /**
14966 * kernel source filename
14967 */
14968
14969 char source_file[256] = { 0 };
14970
14971 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14972
14973 struct stat sst;
14974
14975 if (stat (source_file, &sst) == -1)
14976 {
14977 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14978
14979 return -1;
14980 }
14981
14982 /**
14983 * kernel cached filename
14984 */
14985
14986 char cached_file[256] = { 0 };
14987
14988 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14989
14990 int cached = 1;
14991
14992 struct stat cst;
14993
14994 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14995 {
14996 cached = 0;
14997 }
14998
14999 /**
15000 * kernel compile or load
15001 */
15002
15003 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15004
15005 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15006
15007 if (force_jit_compilation == -1)
15008 {
15009 if (cached == 0)
15010 {
15011 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15012
15013 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15014
15015 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15016
15017 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15018
15019 #ifdef DEBUG
15020 size_t build_log_size = 0;
15021
15022 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15023
15024 if (build_log_size > 1)
15025 {
15026 char *build_log = (char *) malloc (build_log_size + 1);
15027
15028 memset (build_log, 0, build_log_size + 1);
15029
15030 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15031
15032 puts (build_log);
15033
15034 free (build_log);
15035 }
15036 #endif
15037
15038 if (rc != 0)
15039 {
15040 device_param->skipped = true;
15041
15042 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15043
15044 continue;
15045 }
15046
15047 size_t binary_size;
15048
15049 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15050
15051 u8 *binary = (u8 *) mymalloc (binary_size);
15052
15053 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15054
15055 writeProgramBin (cached_file, binary, binary_size);
15056
15057 local_free (binary);
15058 }
15059 else
15060 {
15061 #ifdef DEBUG
15062 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15063 #endif
15064
15065 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15066
15067 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15068
15069 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15070 }
15071 }
15072 else
15073 {
15074 #ifdef DEBUG
15075 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15076 #endif
15077
15078 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15079
15080 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15081
15082 char build_opts_update[1024] = { 0 };
15083
15084 if (force_jit_compilation == 1500)
15085 {
15086 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15087 }
15088 else if (force_jit_compilation == 8900)
15089 {
15090 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);
15091 }
15092 else
15093 {
15094 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15095 }
15096
15097 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15098
15099 #ifdef DEBUG
15100 size_t build_log_size = 0;
15101
15102 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15103
15104 if (build_log_size > 1)
15105 {
15106 char *build_log = (char *) malloc (build_log_size + 1);
15107
15108 memset (build_log, 0, build_log_size + 1);
15109
15110 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15111
15112 puts (build_log);
15113
15114 free (build_log);
15115 }
15116 #endif
15117
15118 if (rc != 0)
15119 {
15120 device_param->skipped = true;
15121
15122 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15123 }
15124 }
15125
15126 local_free (kernel_lengths);
15127 local_free (kernel_sources[0]);
15128 local_free (kernel_sources);
15129 }
15130
15131 /**
15132 * word generator kernel
15133 */
15134
15135 if (attack_mode != ATTACK_MODE_STRAIGHT)
15136 {
15137 /**
15138 * kernel mp source filename
15139 */
15140
15141 char source_file[256] = { 0 };
15142
15143 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15144
15145 struct stat sst;
15146
15147 if (stat (source_file, &sst) == -1)
15148 {
15149 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15150
15151 return -1;
15152 }
15153
15154 /**
15155 * kernel mp cached filename
15156 */
15157
15158 char cached_file[256] = { 0 };
15159
15160 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15161
15162 int cached = 1;
15163
15164 struct stat cst;
15165
15166 if (stat (cached_file, &cst) == -1)
15167 {
15168 cached = 0;
15169 }
15170
15171 /**
15172 * kernel compile or load
15173 */
15174
15175 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15176
15177 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15178
15179 if (cached == 0)
15180 {
15181 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15182 if (quiet == 0) log_info ("");
15183
15184 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15185
15186 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15187
15188 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15189
15190 if (rc != 0)
15191 {
15192 device_param->skipped = true;
15193
15194 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15195
15196 continue;
15197 }
15198
15199 size_t binary_size;
15200
15201 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15202
15203 u8 *binary = (u8 *) mymalloc (binary_size);
15204
15205 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15206
15207 writeProgramBin (cached_file, binary, binary_size);
15208
15209 local_free (binary);
15210 }
15211 else
15212 {
15213 #ifdef DEBUG
15214 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15215 #endif
15216
15217 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15218
15219 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15220
15221 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15222 }
15223
15224 local_free (kernel_lengths);
15225 local_free (kernel_sources[0]);
15226 local_free (kernel_sources);
15227 }
15228
15229 /**
15230 * amplifier kernel
15231 */
15232
15233 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15234 {
15235
15236 }
15237 else
15238 {
15239 /**
15240 * kernel amp source filename
15241 */
15242
15243 char source_file[256] = { 0 };
15244
15245 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15246
15247 struct stat sst;
15248
15249 if (stat (source_file, &sst) == -1)
15250 {
15251 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15252
15253 return -1;
15254 }
15255
15256 /**
15257 * kernel amp cached filename
15258 */
15259
15260 char cached_file[256] = { 0 };
15261
15262 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15263
15264 int cached = 1;
15265
15266 struct stat cst;
15267
15268 if (stat (cached_file, &cst) == -1)
15269 {
15270 cached = 0;
15271 }
15272
15273 /**
15274 * kernel compile or load
15275 */
15276
15277 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15278
15279 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15280
15281 if (cached == 0)
15282 {
15283 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15284 if (quiet == 0) log_info ("");
15285
15286 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15287
15288 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15289
15290 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15291
15292 if (rc != 0)
15293 {
15294 device_param->skipped = true;
15295
15296 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15297
15298 continue;
15299 }
15300
15301 size_t binary_size;
15302
15303 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15304
15305 u8 *binary = (u8 *) mymalloc (binary_size);
15306
15307 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15308
15309 writeProgramBin (cached_file, binary, binary_size);
15310
15311 local_free (binary);
15312 }
15313 else
15314 {
15315 #ifdef DEBUG
15316 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15317 #endif
15318
15319 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15320
15321 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15322
15323 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15324 }
15325
15326 local_free (kernel_lengths);
15327 local_free (kernel_sources[0]);
15328 local_free (kernel_sources);
15329 }
15330
15331 // some algorithm collide too fast, make that impossible
15332
15333 if (benchmark == 1)
15334 {
15335 ((uint *) digests_buf)[0] = -1;
15336 ((uint *) digests_buf)[1] = -1;
15337 ((uint *) digests_buf)[2] = -1;
15338 ((uint *) digests_buf)[3] = -1;
15339 }
15340
15341 /**
15342 * global buffers
15343 */
15344
15345 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15346 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15347 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15348 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15349 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15350 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15351 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15352 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15353 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15354 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15355 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15356 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15357 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15358 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15359 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15360 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15361 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15362 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15363
15364 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);
15365 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);
15366 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);
15367 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);
15368 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);
15369 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);
15370 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);
15371 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);
15372 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15373 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15374 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15375
15376 /**
15377 * special buffers
15378 */
15379
15380 if (attack_kern == ATTACK_KERN_STRAIGHT)
15381 {
15382 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15383 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15384
15385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15386 }
15387 else if (attack_kern == ATTACK_KERN_COMBI)
15388 {
15389 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15390 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15391 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15392 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15393 }
15394 else if (attack_kern == ATTACK_KERN_BF)
15395 {
15396 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15397 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15398 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15399 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15400 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15401 }
15402
15403 if (size_esalts)
15404 {
15405 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15406
15407 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15408 }
15409
15410 /**
15411 * main host data
15412 */
15413
15414 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15415
15416 device_param->pws_buf = pws_buf;
15417
15418 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15419
15420 device_param->combs_buf = combs_buf;
15421
15422 void *hooks_buf = mymalloc (size_hooks);
15423
15424 device_param->hooks_buf = hooks_buf;
15425
15426 /**
15427 * kernel args
15428 */
15429
15430 device_param->kernel_params_buf32[21] = bitmap_mask;
15431 device_param->kernel_params_buf32[22] = bitmap_shift1;
15432 device_param->kernel_params_buf32[23] = bitmap_shift2;
15433 device_param->kernel_params_buf32[24] = 0; // salt_pos
15434 device_param->kernel_params_buf32[25] = 0; // loop_pos
15435 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15436 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15437 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15438 device_param->kernel_params_buf32[29] = 0; // digests_offset
15439 device_param->kernel_params_buf32[30] = 0; // combs_mode
15440 device_param->kernel_params_buf32[31] = 0; // gid_max
15441
15442 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15443 ? &device_param->d_pws_buf
15444 : &device_param->d_pws_amp_buf;
15445 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15446 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15447 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15448 device_param->kernel_params[ 4] = &device_param->d_tmps;
15449 device_param->kernel_params[ 5] = &device_param->d_hooks;
15450 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15451 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15452 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15453 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15454 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15455 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15456 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15457 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15458 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15459 device_param->kernel_params[15] = &device_param->d_digests_buf;
15460 device_param->kernel_params[16] = &device_param->d_digests_shown;
15461 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15462 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15463 device_param->kernel_params[19] = &device_param->d_result;
15464 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15465 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15466 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15467 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15468 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15469 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15470 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15471 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15472 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15473 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15474 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15475 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15476
15477 device_param->kernel_params_mp_buf64[3] = 0;
15478 device_param->kernel_params_mp_buf32[4] = 0;
15479 device_param->kernel_params_mp_buf32[5] = 0;
15480 device_param->kernel_params_mp_buf32[6] = 0;
15481 device_param->kernel_params_mp_buf32[7] = 0;
15482 device_param->kernel_params_mp_buf32[8] = 0;
15483
15484 device_param->kernel_params_mp[0] = NULL;
15485 device_param->kernel_params_mp[1] = NULL;
15486 device_param->kernel_params_mp[2] = NULL;
15487 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15488 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15489 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15490 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15491 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15492 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15493
15494 device_param->kernel_params_mp_l_buf64[3] = 0;
15495 device_param->kernel_params_mp_l_buf32[4] = 0;
15496 device_param->kernel_params_mp_l_buf32[5] = 0;
15497 device_param->kernel_params_mp_l_buf32[6] = 0;
15498 device_param->kernel_params_mp_l_buf32[7] = 0;
15499 device_param->kernel_params_mp_l_buf32[8] = 0;
15500 device_param->kernel_params_mp_l_buf32[9] = 0;
15501
15502 device_param->kernel_params_mp_l[0] = NULL;
15503 device_param->kernel_params_mp_l[1] = NULL;
15504 device_param->kernel_params_mp_l[2] = NULL;
15505 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15506 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15507 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15508 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15509 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15510 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15511 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15512
15513 device_param->kernel_params_mp_r_buf64[3] = 0;
15514 device_param->kernel_params_mp_r_buf32[4] = 0;
15515 device_param->kernel_params_mp_r_buf32[5] = 0;
15516 device_param->kernel_params_mp_r_buf32[6] = 0;
15517 device_param->kernel_params_mp_r_buf32[7] = 0;
15518 device_param->kernel_params_mp_r_buf32[8] = 0;
15519
15520 device_param->kernel_params_mp_r[0] = NULL;
15521 device_param->kernel_params_mp_r[1] = NULL;
15522 device_param->kernel_params_mp_r[2] = NULL;
15523 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15524 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15525 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15526 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15527 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15528 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15529
15530 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15531 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15532
15533 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15534 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15535 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15536 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15537 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15538 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15539 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15540
15541 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15542 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15543
15544 device_param->kernel_params_memset_buf32[1] = 0; // value
15545 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15546
15547 device_param->kernel_params_memset[0] = NULL;
15548 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15549 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15550
15551 /**
15552 * kernel name
15553 */
15554
15555 size_t kernel_wgs_tmp;
15556
15557 char kernel_name[64] = { 0 };
15558
15559 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15560 {
15561 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15562 {
15563 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15564
15565 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15566
15567 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15568
15569 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15570
15571 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15572
15573 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15574 }
15575 else
15576 {
15577 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15578
15579 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15580
15581 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15582
15583 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15584
15585 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15586
15587 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15588 }
15589
15590 if (data.attack_mode == ATTACK_MODE_BF)
15591 {
15592 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15593 {
15594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15595
15596 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15597
15598 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);
15599 }
15600 }
15601 }
15602 else
15603 {
15604 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15605
15606 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15607
15608 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15609
15610 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15611
15612 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15613
15614 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15615
15616 if (opts_type & OPTS_TYPE_HOOK12)
15617 {
15618 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15619
15620 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15621
15622 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);
15623 }
15624
15625 if (opts_type & OPTS_TYPE_HOOK23)
15626 {
15627 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15628
15629 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15630
15631 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);
15632 }
15633 }
15634
15635 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);
15636 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);
15637 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);
15638
15639 for (uint i = 0; i <= 20; i++)
15640 {
15641 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15642 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15643 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15644
15645 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15646 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15647 }
15648
15649 for (uint i = 21; i <= 31; i++)
15650 {
15651 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15652 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15653 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15654
15655 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15656 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15657 }
15658
15659 // GPU memset
15660
15661 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15662
15663 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);
15664
15665 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15666 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15667 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15668
15669 // MP start
15670
15671 if (attack_mode == ATTACK_MODE_BF)
15672 {
15673 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15674 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15675
15676 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);
15677 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);
15678
15679 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15680 {
15681 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15682 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15683 }
15684 }
15685 else if (attack_mode == ATTACK_MODE_HYBRID1)
15686 {
15687 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15688
15689 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);
15690 }
15691 else if (attack_mode == ATTACK_MODE_HYBRID2)
15692 {
15693 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15694
15695 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);
15696 }
15697
15698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15699 {
15700 // nothing to do
15701 }
15702 else
15703 {
15704 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15705
15706 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);
15707 }
15708
15709 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15710 {
15711 // nothing to do
15712 }
15713 else
15714 {
15715 for (uint i = 0; i < 5; i++)
15716 {
15717 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15718 }
15719
15720 for (uint i = 5; i < 7; i++)
15721 {
15722 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15723 }
15724 }
15725
15726 // maybe this has been updated by clGetKernelWorkGroupInfo()
15727 // value can only be decreased, so we don't need to reallocate buffers
15728
15729 device_param->kernel_threads = kernel_threads;
15730
15731 // zero some data buffers
15732
15733 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15734 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15735 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15736 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15737 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15738 run_kernel_bzero (device_param, device_param->d_result, size_results);
15739
15740 /**
15741 * special buffers
15742 */
15743
15744 if (attack_kern == ATTACK_KERN_STRAIGHT)
15745 {
15746 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15747 }
15748 else if (attack_kern == ATTACK_KERN_COMBI)
15749 {
15750 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15751 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15752 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15753 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15754 }
15755 else if (attack_kern == ATTACK_KERN_BF)
15756 {
15757 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15758 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15759 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15760 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15761 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15762 }
15763
15764 #if defined(HAVE_HWMON)
15765
15766 /**
15767 * Store initial fanspeed if gpu_temp_retain is enabled
15768 */
15769
15770 if (gpu_temp_disable == 0)
15771 {
15772 if (gpu_temp_retain != 0)
15773 {
15774 hc_thread_mutex_lock (mux_adl);
15775
15776 if (data.hm_device[device_id].fan_get_supported == 1)
15777 {
15778 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15779 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15780
15781 temp_retain_fanspeed_value[device_id] = fanspeed;
15782 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15783
15784 // we also set it to tell the OS we take control over the fan and it's automatic controller
15785 // if it was set to automatic. we do not control user-defined fanspeeds.
15786
15787 if (fanpolicy == 1)
15788 {
15789 data.hm_device[device_id].fan_set_supported = 1;
15790
15791 int rc = -1;
15792
15793 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15794 {
15795 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15796 }
15797 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15798 {
15799
15800 }
15801
15802 if (rc == 0)
15803 {
15804 data.hm_device[device_id].fan_set_supported = 1;
15805 }
15806 else
15807 {
15808 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15809
15810 data.hm_device[device_id].fan_set_supported = 0;
15811 }
15812 }
15813 else
15814 {
15815 data.hm_device[device_id].fan_set_supported = 0;
15816 }
15817 }
15818
15819 hc_thread_mutex_unlock (mux_adl);
15820 }
15821 }
15822
15823 #endif // HAVE_HWMON
15824 }
15825
15826 if (data.quiet == 0) log_info_nn ("");
15827
15828 /**
15829 * In benchmark-mode, inform user which algorithm is checked
15830 */
15831
15832 if (benchmark == 1)
15833 {
15834 if (machine_readable == 0)
15835 {
15836 quiet = 0;
15837
15838 data.quiet = quiet;
15839
15840 char *hash_type = strhashtype (data.hash_mode); // not a bug
15841
15842 log_info ("Hashtype: %s", hash_type);
15843 log_info ("");
15844 }
15845 }
15846
15847 /**
15848 * keep track of the progress
15849 */
15850
15851 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15852 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15853 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15854
15855 /**
15856 * open filehandles
15857 */
15858
15859 #if _WIN
15860 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15861 {
15862 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15863
15864 return (-1);
15865 }
15866
15867 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15868 {
15869 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15870
15871 return (-1);
15872 }
15873
15874 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15875 {
15876 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15877
15878 return (-1);
15879 }
15880 #endif
15881
15882 /**
15883 * dictionary pad
15884 */
15885
15886 segment_size *= (1024 * 1024);
15887
15888 data.segment_size = segment_size;
15889
15890 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15891
15892 wl_data->buf = (char *) mymalloc (segment_size);
15893 wl_data->avail = segment_size;
15894 wl_data->incr = segment_size;
15895 wl_data->cnt = 0;
15896 wl_data->pos = 0;
15897
15898 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15899
15900 data.wordlist_mode = wordlist_mode;
15901
15902 cs_t *css_buf = NULL;
15903 uint css_cnt = 0;
15904 uint dictcnt = 0;
15905 uint maskcnt = 1;
15906 char **masks = NULL;
15907 char **dictfiles = NULL;
15908
15909 uint mask_from_file = 0;
15910
15911 if (attack_mode == ATTACK_MODE_STRAIGHT)
15912 {
15913 if (wordlist_mode == WL_MODE_FILE)
15914 {
15915 int wls_left = myargc - (optind + 1);
15916
15917 for (int i = 0; i < wls_left; i++)
15918 {
15919 char *l0_filename = myargv[optind + 1 + i];
15920
15921 struct stat l0_stat;
15922
15923 if (stat (l0_filename, &l0_stat) == -1)
15924 {
15925 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15926
15927 return (-1);
15928 }
15929
15930 uint is_dir = S_ISDIR (l0_stat.st_mode);
15931
15932 if (is_dir == 0)
15933 {
15934 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15935
15936 dictcnt++;
15937
15938 dictfiles[dictcnt - 1] = l0_filename;
15939 }
15940 else
15941 {
15942 // do not allow --keyspace w/ a directory
15943
15944 if (keyspace == 1)
15945 {
15946 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15947
15948 return (-1);
15949 }
15950
15951 char **dictionary_files = NULL;
15952
15953 dictionary_files = scan_directory (l0_filename);
15954
15955 if (dictionary_files != NULL)
15956 {
15957 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15958
15959 for (int d = 0; dictionary_files[d] != NULL; d++)
15960 {
15961 char *l1_filename = dictionary_files[d];
15962
15963 struct stat l1_stat;
15964
15965 if (stat (l1_filename, &l1_stat) == -1)
15966 {
15967 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15968
15969 return (-1);
15970 }
15971
15972 if (S_ISREG (l1_stat.st_mode))
15973 {
15974 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15975
15976 dictcnt++;
15977
15978 dictfiles[dictcnt - 1] = strdup (l1_filename);
15979 }
15980 }
15981 }
15982
15983 local_free (dictionary_files);
15984 }
15985 }
15986
15987 if (dictcnt < 1)
15988 {
15989 log_error ("ERROR: No usable dictionary file found.");
15990
15991 return (-1);
15992 }
15993 }
15994 else if (wordlist_mode == WL_MODE_STDIN)
15995 {
15996 dictcnt = 1;
15997 }
15998 }
15999 else if (attack_mode == ATTACK_MODE_COMBI)
16000 {
16001 // display
16002
16003 char *dictfile1 = myargv[optind + 1 + 0];
16004 char *dictfile2 = myargv[optind + 1 + 1];
16005
16006 // find the bigger dictionary and use as base
16007
16008 FILE *fp1 = NULL;
16009 FILE *fp2 = NULL;
16010
16011 struct stat tmp_stat;
16012
16013 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16014 {
16015 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16016
16017 return (-1);
16018 }
16019
16020 if (stat (dictfile1, &tmp_stat) == -1)
16021 {
16022 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16023
16024 fclose (fp1);
16025
16026 return (-1);
16027 }
16028
16029 if (S_ISDIR (tmp_stat.st_mode))
16030 {
16031 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16032
16033 fclose (fp1);
16034
16035 return (-1);
16036 }
16037
16038 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16039 {
16040 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16041
16042 fclose (fp1);
16043
16044 return (-1);
16045 }
16046
16047 if (stat (dictfile2, &tmp_stat) == -1)
16048 {
16049 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16050
16051 fclose (fp1);
16052 fclose (fp2);
16053
16054 return (-1);
16055 }
16056
16057 if (S_ISDIR (tmp_stat.st_mode))
16058 {
16059 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16060
16061 fclose (fp1);
16062 fclose (fp2);
16063
16064 return (-1);
16065 }
16066
16067 data.combs_cnt = 1;
16068
16069 data.quiet = 1;
16070
16071 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16072
16073 data.quiet = quiet;
16074
16075 if (words1_cnt == 0)
16076 {
16077 log_error ("ERROR: %s: empty file", dictfile1);
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 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16090
16091 data.quiet = quiet;
16092
16093 if (words2_cnt == 0)
16094 {
16095 log_error ("ERROR: %s: empty file", dictfile2);
16096
16097 fclose (fp1);
16098 fclose (fp2);
16099
16100 return (-1);
16101 }
16102
16103 fclose (fp1);
16104 fclose (fp2);
16105
16106 data.dictfile = dictfile1;
16107 data.dictfile2 = dictfile2;
16108
16109 if (words1_cnt >= words2_cnt)
16110 {
16111 data.combs_cnt = words2_cnt;
16112 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16113
16114 dictfiles = &data.dictfile;
16115
16116 dictcnt = 1;
16117 }
16118 else
16119 {
16120 data.combs_cnt = words1_cnt;
16121 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16122
16123 dictfiles = &data.dictfile2;
16124
16125 dictcnt = 1;
16126
16127 // we also have to switch wordlist related rules!
16128
16129 char *tmpc = data.rule_buf_l;
16130
16131 data.rule_buf_l = data.rule_buf_r;
16132 data.rule_buf_r = tmpc;
16133
16134 int tmpi = data.rule_len_l;
16135
16136 data.rule_len_l = data.rule_len_r;
16137 data.rule_len_r = tmpi;
16138 }
16139 }
16140 else if (attack_mode == ATTACK_MODE_BF)
16141 {
16142 char *mask = NULL;
16143
16144 maskcnt = 0;
16145
16146 if (benchmark == 0)
16147 {
16148 mask = myargv[optind + 1];
16149
16150 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16151
16152 if ((optind + 2) <= myargc)
16153 {
16154 struct stat file_stat;
16155
16156 if (stat (mask, &file_stat) == -1)
16157 {
16158 maskcnt = 1;
16159
16160 masks[maskcnt - 1] = mystrdup (mask);
16161 }
16162 else
16163 {
16164 int wls_left = myargc - (optind + 1);
16165
16166 uint masks_avail = INCR_MASKS;
16167
16168 for (int i = 0; i < wls_left; i++)
16169 {
16170 if (i != 0)
16171 {
16172 mask = myargv[optind + 1 + i];
16173
16174 if (stat (mask, &file_stat) == -1)
16175 {
16176 log_error ("ERROR: %s: %s", mask, strerror (errno));
16177
16178 return (-1);
16179 }
16180 }
16181
16182 uint is_file = S_ISREG (file_stat.st_mode);
16183
16184 if (is_file == 1)
16185 {
16186 FILE *mask_fp;
16187
16188 if ((mask_fp = fopen (mask, "r")) == NULL)
16189 {
16190 log_error ("ERROR: %s: %s", mask, strerror (errno));
16191
16192 return (-1);
16193 }
16194
16195 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16196
16197 while (!feof (mask_fp))
16198 {
16199 memset (line_buf, 0, HCBUFSIZ);
16200
16201 int line_len = fgetl (mask_fp, line_buf);
16202
16203 if (line_len == 0) continue;
16204
16205 if (line_buf[0] == '#') continue;
16206
16207 if (masks_avail == maskcnt)
16208 {
16209 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16210
16211 masks_avail += INCR_MASKS;
16212 }
16213
16214 masks[maskcnt] = mystrdup (line_buf);
16215
16216 maskcnt++;
16217 }
16218
16219 myfree (line_buf);
16220
16221 fclose (mask_fp);
16222 }
16223 else
16224 {
16225 log_error ("ERROR: %s: unsupported file-type", mask);
16226
16227 return (-1);
16228 }
16229 }
16230
16231 mask_from_file = 1;
16232 }
16233 }
16234 else
16235 {
16236 custom_charset_1 = (char *) "?l?d?u";
16237 custom_charset_2 = (char *) "?l?d";
16238 custom_charset_3 = (char *) "?l?d*!$@_";
16239
16240 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16241 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16242 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16243
16244 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16245
16246 wordlist_mode = WL_MODE_MASK;
16247
16248 data.wordlist_mode = wordlist_mode;
16249
16250 increment = 1;
16251
16252 maskcnt = 1;
16253 }
16254 }
16255 else
16256 {
16257 /**
16258 * generate full masks and charsets
16259 */
16260
16261 masks = (char **) mymalloc (sizeof (char *));
16262
16263 switch (hash_mode)
16264 {
16265 case 1731: pw_min = 5;
16266 pw_max = 5;
16267 mask = mystrdup ("?b?b?b?b?b");
16268 break;
16269 case 12500: pw_min = 5;
16270 pw_max = 5;
16271 mask = mystrdup ("?b?b?b?b?b");
16272 break;
16273 default: pw_min = 7;
16274 pw_max = 7;
16275 mask = mystrdup ("?b?b?b?b?b?b?b");
16276 break;
16277 }
16278
16279 maskcnt = 1;
16280
16281 masks[maskcnt - 1] = mystrdup (mask);
16282
16283 wordlist_mode = WL_MODE_MASK;
16284
16285 data.wordlist_mode = wordlist_mode;
16286
16287 increment = 1;
16288 }
16289
16290 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16291
16292 if (increment)
16293 {
16294 if (increment_min > pw_min) pw_min = increment_min;
16295
16296 if (increment_max < pw_max) pw_max = increment_max;
16297 }
16298 }
16299 else if (attack_mode == ATTACK_MODE_HYBRID1)
16300 {
16301 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16302
16303 // display
16304
16305 char *mask = myargv[myargc - 1];
16306
16307 maskcnt = 0;
16308
16309 masks = (char **) mymalloc (1 * sizeof (char *));
16310
16311 // mod
16312
16313 struct stat file_stat;
16314
16315 if (stat (mask, &file_stat) == -1)
16316 {
16317 maskcnt = 1;
16318
16319 masks[maskcnt - 1] = mystrdup (mask);
16320 }
16321 else
16322 {
16323 uint is_file = S_ISREG (file_stat.st_mode);
16324
16325 if (is_file == 1)
16326 {
16327 FILE *mask_fp;
16328
16329 if ((mask_fp = fopen (mask, "r")) == NULL)
16330 {
16331 log_error ("ERROR: %s: %s", mask, strerror (errno));
16332
16333 return (-1);
16334 }
16335
16336 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16337
16338 uint masks_avail = 1;
16339
16340 while (!feof (mask_fp))
16341 {
16342 memset (line_buf, 0, HCBUFSIZ);
16343
16344 int line_len = fgetl (mask_fp, line_buf);
16345
16346 if (line_len == 0) continue;
16347
16348 if (line_buf[0] == '#') continue;
16349
16350 if (masks_avail == maskcnt)
16351 {
16352 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16353
16354 masks_avail += INCR_MASKS;
16355 }
16356
16357 masks[maskcnt] = mystrdup (line_buf);
16358
16359 maskcnt++;
16360 }
16361
16362 myfree (line_buf);
16363
16364 fclose (mask_fp);
16365
16366 mask_from_file = 1;
16367 }
16368 else
16369 {
16370 maskcnt = 1;
16371
16372 masks[maskcnt - 1] = mystrdup (mask);
16373 }
16374 }
16375
16376 // base
16377
16378 int wls_left = myargc - (optind + 2);
16379
16380 for (int i = 0; i < wls_left; i++)
16381 {
16382 char *filename = myargv[optind + 1 + i];
16383
16384 struct stat file_stat;
16385
16386 if (stat (filename, &file_stat) == -1)
16387 {
16388 log_error ("ERROR: %s: %s", filename, strerror (errno));
16389
16390 return (-1);
16391 }
16392
16393 uint is_dir = S_ISDIR (file_stat.st_mode);
16394
16395 if (is_dir == 0)
16396 {
16397 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16398
16399 dictcnt++;
16400
16401 dictfiles[dictcnt - 1] = filename;
16402 }
16403 else
16404 {
16405 // do not allow --keyspace w/ a directory
16406
16407 if (keyspace == 1)
16408 {
16409 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16410
16411 return (-1);
16412 }
16413
16414 char **dictionary_files = NULL;
16415
16416 dictionary_files = scan_directory (filename);
16417
16418 if (dictionary_files != NULL)
16419 {
16420 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16421
16422 for (int d = 0; dictionary_files[d] != NULL; d++)
16423 {
16424 char *l1_filename = dictionary_files[d];
16425
16426 struct stat l1_stat;
16427
16428 if (stat (l1_filename, &l1_stat) == -1)
16429 {
16430 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16431
16432 return (-1);
16433 }
16434
16435 if (S_ISREG (l1_stat.st_mode))
16436 {
16437 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16438
16439 dictcnt++;
16440
16441 dictfiles[dictcnt - 1] = strdup (l1_filename);
16442 }
16443 }
16444 }
16445
16446 local_free (dictionary_files);
16447 }
16448 }
16449
16450 if (dictcnt < 1)
16451 {
16452 log_error ("ERROR: No usable dictionary file found.");
16453
16454 return (-1);
16455 }
16456
16457 if (increment)
16458 {
16459 maskcnt = 0;
16460
16461 uint mask_min = increment_min; // we can't reject smaller masks here
16462 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16463
16464 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16465 {
16466 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16467
16468 if (cur_mask == NULL) break;
16469
16470 masks[maskcnt] = cur_mask;
16471
16472 maskcnt++;
16473
16474 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16475 }
16476 }
16477 }
16478 else if (attack_mode == ATTACK_MODE_HYBRID2)
16479 {
16480 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16481
16482 // display
16483
16484 char *mask = myargv[optind + 1 + 0];
16485
16486 maskcnt = 0;
16487
16488 masks = (char **) mymalloc (1 * sizeof (char *));
16489
16490 // mod
16491
16492 struct stat file_stat;
16493
16494 if (stat (mask, &file_stat) == -1)
16495 {
16496 maskcnt = 1;
16497
16498 masks[maskcnt - 1] = mystrdup (mask);
16499 }
16500 else
16501 {
16502 uint is_file = S_ISREG (file_stat.st_mode);
16503
16504 if (is_file == 1)
16505 {
16506 FILE *mask_fp;
16507
16508 if ((mask_fp = fopen (mask, "r")) == NULL)
16509 {
16510 log_error ("ERROR: %s: %s", mask, strerror (errno));
16511
16512 return (-1);
16513 }
16514
16515 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16516
16517 uint masks_avail = 1;
16518
16519 while (!feof (mask_fp))
16520 {
16521 memset (line_buf, 0, HCBUFSIZ);
16522
16523 int line_len = fgetl (mask_fp, line_buf);
16524
16525 if (line_len == 0) continue;
16526
16527 if (line_buf[0] == '#') continue;
16528
16529 if (masks_avail == maskcnt)
16530 {
16531 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16532
16533 masks_avail += INCR_MASKS;
16534 }
16535
16536 masks[maskcnt] = mystrdup (line_buf);
16537
16538 maskcnt++;
16539 }
16540
16541 myfree (line_buf);
16542
16543 fclose (mask_fp);
16544
16545 mask_from_file = 1;
16546 }
16547 else
16548 {
16549 maskcnt = 1;
16550
16551 masks[maskcnt - 1] = mystrdup (mask);
16552 }
16553 }
16554
16555 // base
16556
16557 int wls_left = myargc - (optind + 2);
16558
16559 for (int i = 0; i < wls_left; i++)
16560 {
16561 char *filename = myargv[optind + 2 + i];
16562
16563 struct stat file_stat;
16564
16565 if (stat (filename, &file_stat) == -1)
16566 {
16567 log_error ("ERROR: %s: %s", filename, strerror (errno));
16568
16569 return (-1);
16570 }
16571
16572 uint is_dir = S_ISDIR (file_stat.st_mode);
16573
16574 if (is_dir == 0)
16575 {
16576 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16577
16578 dictcnt++;
16579
16580 dictfiles[dictcnt - 1] = filename;
16581 }
16582 else
16583 {
16584 // do not allow --keyspace w/ a directory
16585
16586 if (keyspace == 1)
16587 {
16588 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16589
16590 return (-1);
16591 }
16592
16593 char **dictionary_files = NULL;
16594
16595 dictionary_files = scan_directory (filename);
16596
16597 if (dictionary_files != NULL)
16598 {
16599 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16600
16601 for (int d = 0; dictionary_files[d] != NULL; d++)
16602 {
16603 char *l1_filename = dictionary_files[d];
16604
16605 struct stat l1_stat;
16606
16607 if (stat (l1_filename, &l1_stat) == -1)
16608 {
16609 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16610
16611 return (-1);
16612 }
16613
16614 if (S_ISREG (l1_stat.st_mode))
16615 {
16616 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16617
16618 dictcnt++;
16619
16620 dictfiles[dictcnt - 1] = strdup (l1_filename);
16621 }
16622 }
16623 }
16624
16625 local_free (dictionary_files);
16626 }
16627 }
16628
16629 if (dictcnt < 1)
16630 {
16631 log_error ("ERROR: No usable dictionary file found.");
16632
16633 return (-1);
16634 }
16635
16636 if (increment)
16637 {
16638 maskcnt = 0;
16639
16640 uint mask_min = increment_min; // we can't reject smaller masks here
16641 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16642
16643 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16644 {
16645 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16646
16647 if (cur_mask == NULL) break;
16648
16649 masks[maskcnt] = cur_mask;
16650
16651 maskcnt++;
16652
16653 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16654 }
16655 }
16656 }
16657
16658 data.pw_min = pw_min;
16659 data.pw_max = pw_max;
16660
16661 /**
16662 * weak hash check
16663 */
16664
16665 if (weak_hash_threshold >= salts_cnt)
16666 {
16667 hc_device_param_t *device_param = NULL;
16668
16669 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16670 {
16671 device_param = &data.devices_param[device_id];
16672
16673 if (device_param->skipped) continue;
16674
16675 break;
16676 }
16677
16678 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16679
16680 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16681 {
16682 weak_hash_check (device_param, salt_pos);
16683 }
16684
16685 // Display hack, guarantee that there is at least one \r before real start
16686
16687 //if (data.quiet == 0) log_info ("");
16688 }
16689
16690 /**
16691 * status and monitor threads
16692 */
16693
16694 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16695
16696 hc_thread_t i_thread = 0;
16697
16698 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16699 {
16700 hc_thread_create (i_thread, thread_keypress, &benchmark);
16701 }
16702
16703 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16704
16705 uint ni_threads_cnt = 0;
16706
16707 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16708
16709 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16710
16711 ni_threads_cnt++;
16712
16713 /**
16714 * Outfile remove
16715 */
16716
16717 if (keyspace == 0)
16718 {
16719 if (outfile_check_timer != 0)
16720 {
16721 if (data.outfile_check_directory != NULL)
16722 {
16723 if ((hash_mode != 5200) &&
16724 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16725 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16726 (hash_mode != 9000))
16727 {
16728 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16729
16730 ni_threads_cnt++;
16731 }
16732 else
16733 {
16734 outfile_check_timer = 0;
16735 }
16736 }
16737 else
16738 {
16739 outfile_check_timer = 0;
16740 }
16741 }
16742 }
16743
16744 /**
16745 * Inform the user if we got some hashes remove because of the pot file remove feature
16746 */
16747
16748 if (data.quiet == 0)
16749 {
16750 if (potfile_remove_cracks > 0)
16751 {
16752 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16753 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16754 }
16755 }
16756
16757 data.outfile_check_timer = outfile_check_timer;
16758
16759 /**
16760 * main loop
16761 */
16762
16763 char **induction_dictionaries = NULL;
16764
16765 int induction_dictionaries_cnt = 0;
16766
16767 hcstat_table_t *root_table_buf = NULL;
16768 hcstat_table_t *markov_table_buf = NULL;
16769
16770 uint initial_restore_done = 0;
16771
16772 data.maskcnt = maskcnt;
16773
16774 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16775 {
16776 if (data.devices_status == STATUS_CRACKED) break;
16777
16778 data.devices_status = STATUS_INIT;
16779
16780 if (maskpos > rd->maskpos)
16781 {
16782 rd->dictpos = 0;
16783 }
16784
16785 rd->maskpos = maskpos;
16786 data.maskpos = maskpos;
16787
16788 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16789 {
16790 char *mask = masks[maskpos];
16791
16792 if (mask_from_file == 1)
16793 {
16794 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16795
16796 char *str_ptr;
16797 uint str_pos;
16798
16799 uint mask_offset = 0;
16800
16801 uint separator_cnt;
16802
16803 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16804 {
16805 str_ptr = strstr (mask + mask_offset, ",");
16806
16807 if (str_ptr == NULL) break;
16808
16809 str_pos = str_ptr - mask;
16810
16811 // escaped separator, i.e. "\,"
16812
16813 if (str_pos > 0)
16814 {
16815 if (mask[str_pos - 1] == '\\')
16816 {
16817 separator_cnt --;
16818
16819 mask_offset = str_pos + 1;
16820
16821 continue;
16822 }
16823 }
16824
16825 // reset the offset
16826
16827 mask_offset = 0;
16828
16829 mask[str_pos] = '\0';
16830
16831 switch (separator_cnt)
16832 {
16833 case 0:
16834 mp_reset_usr (mp_usr, 0);
16835
16836 custom_charset_1 = mask;
16837 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16838 break;
16839
16840 case 1:
16841 mp_reset_usr (mp_usr, 1);
16842
16843 custom_charset_2 = mask;
16844 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16845 break;
16846
16847 case 2:
16848 mp_reset_usr (mp_usr, 2);
16849
16850 custom_charset_3 = mask;
16851 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16852 break;
16853
16854 case 3:
16855 mp_reset_usr (mp_usr, 3);
16856
16857 custom_charset_4 = mask;
16858 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16859 break;
16860 }
16861
16862 mask = mask + str_pos + 1;
16863 }
16864 }
16865
16866 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16867 {
16868 if (maskpos > 0)
16869 {
16870 local_free (css_buf);
16871 local_free (data.root_css_buf);
16872 local_free (data.markov_css_buf);
16873
16874 local_free (masks[maskpos - 1]);
16875 }
16876
16877 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16878
16879 data.mask = mask;
16880 data.css_cnt = css_cnt;
16881 data.css_buf = css_buf;
16882
16883 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16884
16885 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16886
16887 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16888 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16889
16890 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16891
16892 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16893
16894 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16895 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16896
16897 data.root_css_buf = root_css_buf;
16898 data.markov_css_buf = markov_css_buf;
16899
16900 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16901
16902 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16903
16904 local_free (root_table_buf);
16905 local_free (markov_table_buf);
16906
16907 // args
16908
16909 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16910 {
16911 hc_device_param_t *device_param = &data.devices_param[device_id];
16912
16913 if (device_param->skipped) continue;
16914
16915 device_param->kernel_params_mp[0] = &device_param->d_combs;
16916 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16917 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16918
16919 device_param->kernel_params_mp_buf64[3] = 0;
16920 device_param->kernel_params_mp_buf32[4] = css_cnt;
16921 device_param->kernel_params_mp_buf32[5] = 0;
16922 device_param->kernel_params_mp_buf32[6] = 0;
16923 device_param->kernel_params_mp_buf32[7] = 0;
16924
16925 if (attack_mode == ATTACK_MODE_HYBRID1)
16926 {
16927 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16928 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16929 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16930 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16931 }
16932 else if (attack_mode == ATTACK_MODE_HYBRID2)
16933 {
16934 device_param->kernel_params_mp_buf32[5] = 0;
16935 device_param->kernel_params_mp_buf32[6] = 0;
16936 device_param->kernel_params_mp_buf32[7] = 0;
16937 }
16938
16939 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]);
16940 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]);
16941 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]);
16942
16943 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);
16944 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);
16945 }
16946 }
16947 else if (attack_mode == ATTACK_MODE_BF)
16948 {
16949 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16950
16951 if (increment)
16952 {
16953 for (uint i = 0; i < dictcnt; i++)
16954 {
16955 local_free (dictfiles[i]);
16956 }
16957
16958 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16959 {
16960 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16961
16962 if (l1_filename == NULL) break;
16963
16964 dictcnt++;
16965
16966 dictfiles[dictcnt - 1] = l1_filename;
16967 }
16968 }
16969 else
16970 {
16971 dictcnt++;
16972
16973 dictfiles[dictcnt - 1] = mask;
16974 }
16975
16976 if (dictcnt == 0)
16977 {
16978 log_error ("ERROR: Mask is too small");
16979
16980 return (-1);
16981 }
16982 }
16983 }
16984
16985 free (induction_dictionaries);
16986
16987 // induction_dictionaries_cnt = 0; // implied
16988
16989 if (attack_mode != ATTACK_MODE_BF)
16990 {
16991 if (keyspace == 0)
16992 {
16993 induction_dictionaries = scan_directory (induction_directory);
16994
16995 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16996 }
16997 }
16998
16999 if (induction_dictionaries_cnt)
17000 {
17001 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17002 }
17003
17004 /**
17005 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17006 */
17007 if (keyspace == 1)
17008 {
17009 if ((maskcnt > 1) || (dictcnt > 1))
17010 {
17011 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17012
17013 return (-1);
17014 }
17015 }
17016
17017 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17018 {
17019 char *subid = logfile_generate_subid ();
17020
17021 data.subid = subid;
17022
17023 logfile_sub_msg ("START");
17024
17025 data.devices_status = STATUS_INIT;
17026
17027 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17028 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17029 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17030
17031 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17032
17033 data.cpt_pos = 0;
17034
17035 data.cpt_start = time (NULL);
17036
17037 data.cpt_total = 0;
17038
17039 if (data.restore == 0)
17040 {
17041 rd->words_cur = skip;
17042
17043 skip = 0;
17044
17045 data.skip = 0;
17046 }
17047
17048 data.ms_paused = 0;
17049
17050 data.kernel_power_div = 0;
17051
17052 data.words_cur = rd->words_cur;
17053
17054 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17055 {
17056 hc_device_param_t *device_param = &data.devices_param[device_id];
17057
17058 if (device_param->skipped) continue;
17059
17060 device_param->speed_pos = 0;
17061
17062 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17063 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17064
17065 device_param->exec_pos = 0;
17066
17067 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17068
17069 device_param->outerloop_pos = 0;
17070 device_param->outerloop_left = 0;
17071 device_param->innerloop_pos = 0;
17072 device_param->innerloop_left = 0;
17073
17074 // some more resets:
17075
17076 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17077
17078 device_param->pws_cnt = 0;
17079
17080 device_param->words_off = 0;
17081 device_param->words_done = 0;
17082 }
17083
17084 // figure out some workload
17085
17086 if (attack_mode == ATTACK_MODE_STRAIGHT)
17087 {
17088 if (data.wordlist_mode == WL_MODE_FILE)
17089 {
17090 char *dictfile = NULL;
17091
17092 if (induction_dictionaries_cnt)
17093 {
17094 dictfile = induction_dictionaries[0];
17095 }
17096 else
17097 {
17098 dictfile = dictfiles[dictpos];
17099 }
17100
17101 data.dictfile = dictfile;
17102
17103 logfile_sub_string (dictfile);
17104
17105 for (uint i = 0; i < rp_files_cnt; i++)
17106 {
17107 logfile_sub_var_string ("rulefile", rp_files[i]);
17108 }
17109
17110 FILE *fd2 = fopen (dictfile, "rb");
17111
17112 if (fd2 == NULL)
17113 {
17114 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17115
17116 return (-1);
17117 }
17118
17119 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17120
17121 fclose (fd2);
17122
17123 if (data.words_cnt == 0)
17124 {
17125 if (data.devices_status == STATUS_CRACKED) break;
17126 if (data.devices_status == STATUS_ABORTED) break;
17127
17128 dictpos++;
17129
17130 continue;
17131 }
17132 }
17133 }
17134 else if (attack_mode == ATTACK_MODE_COMBI)
17135 {
17136 char *dictfile = data.dictfile;
17137 char *dictfile2 = data.dictfile2;
17138
17139 logfile_sub_string (dictfile);
17140 logfile_sub_string (dictfile2);
17141
17142 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17143 {
17144 FILE *fd2 = fopen (dictfile, "rb");
17145
17146 if (fd2 == NULL)
17147 {
17148 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17149
17150 return (-1);
17151 }
17152
17153 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17154
17155 fclose (fd2);
17156 }
17157 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17158 {
17159 FILE *fd2 = fopen (dictfile2, "rb");
17160
17161 if (fd2 == NULL)
17162 {
17163 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17164
17165 return (-1);
17166 }
17167
17168 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17169
17170 fclose (fd2);
17171 }
17172
17173 if (data.words_cnt == 0)
17174 {
17175 if (data.devices_status == STATUS_CRACKED) break;
17176 if (data.devices_status == STATUS_ABORTED) break;
17177
17178 dictpos++;
17179
17180 continue;
17181 }
17182 }
17183 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17184 {
17185 char *dictfile = NULL;
17186
17187 if (induction_dictionaries_cnt)
17188 {
17189 dictfile = induction_dictionaries[0];
17190 }
17191 else
17192 {
17193 dictfile = dictfiles[dictpos];
17194 }
17195
17196 data.dictfile = dictfile;
17197
17198 char *mask = data.mask;
17199
17200 logfile_sub_string (dictfile);
17201 logfile_sub_string (mask);
17202
17203 FILE *fd2 = fopen (dictfile, "rb");
17204
17205 if (fd2 == NULL)
17206 {
17207 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17208
17209 return (-1);
17210 }
17211
17212 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17213
17214 fclose (fd2);
17215
17216 if (data.words_cnt == 0)
17217 {
17218 if (data.devices_status == STATUS_CRACKED) break;
17219 if (data.devices_status == STATUS_ABORTED) break;
17220
17221 dictpos++;
17222
17223 continue;
17224 }
17225 }
17226 else if (attack_mode == ATTACK_MODE_BF)
17227 {
17228 local_free (css_buf);
17229 local_free (data.root_css_buf);
17230 local_free (data.markov_css_buf);
17231
17232 char *mask = dictfiles[dictpos];
17233
17234 logfile_sub_string (mask);
17235
17236 // base
17237
17238 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17239
17240 if (opts_type & OPTS_TYPE_PT_UNICODE)
17241 {
17242 uint css_cnt_unicode = css_cnt * 2;
17243
17244 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17245
17246 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17247 {
17248 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17249
17250 css_buf_unicode[j + 1].cs_buf[0] = 0;
17251 css_buf_unicode[j + 1].cs_len = 1;
17252 }
17253
17254 free (css_buf);
17255
17256 css_buf = css_buf_unicode;
17257 css_cnt = css_cnt_unicode;
17258 }
17259
17260 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17261
17262 uint mask_min = pw_min;
17263 uint mask_max = pw_max;
17264
17265 if (opts_type & OPTS_TYPE_PT_UNICODE)
17266 {
17267 mask_min *= 2;
17268 mask_max *= 2;
17269 }
17270
17271 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17272 {
17273 if (css_cnt < mask_min)
17274 {
17275 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17276 }
17277
17278 if (css_cnt > mask_max)
17279 {
17280 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17281 }
17282
17283 // skip to next mask
17284
17285 dictpos++;
17286
17287 rd->dictpos = dictpos;
17288
17289 logfile_sub_msg ("STOP");
17290
17291 continue;
17292 }
17293
17294 uint save_css_cnt = css_cnt;
17295
17296 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17297 {
17298 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17299 {
17300 uint salt_len = (uint) data.salts_buf[0].salt_len;
17301 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17302
17303 uint css_cnt_salt = css_cnt + salt_len;
17304
17305 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17306
17307 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17308
17309 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17310 {
17311 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17312 css_buf_salt[j].cs_len = 1;
17313 }
17314
17315 free (css_buf);
17316
17317 css_buf = css_buf_salt;
17318 css_cnt = css_cnt_salt;
17319 }
17320 }
17321
17322 data.mask = mask;
17323 data.css_cnt = css_cnt;
17324 data.css_buf = css_buf;
17325
17326 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17327
17328 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17329
17330 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17331
17332 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17333 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17334
17335 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17336
17337 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17338
17339 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17340 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17341
17342 data.root_css_buf = root_css_buf;
17343 data.markov_css_buf = markov_css_buf;
17344
17345 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17346
17347 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17348
17349 local_free (root_table_buf);
17350 local_free (markov_table_buf);
17351
17352 // copy + args
17353
17354 uint css_cnt_l = css_cnt;
17355 uint css_cnt_r;
17356
17357 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17358 {
17359 if (save_css_cnt < 6)
17360 {
17361 css_cnt_r = 1;
17362 }
17363 else if (save_css_cnt == 6)
17364 {
17365 css_cnt_r = 2;
17366 }
17367 else
17368 {
17369 if (opts_type & OPTS_TYPE_PT_UNICODE)
17370 {
17371 if (save_css_cnt == 8 || save_css_cnt == 10)
17372 {
17373 css_cnt_r = 2;
17374 }
17375 else
17376 {
17377 css_cnt_r = 4;
17378 }
17379 }
17380 else
17381 {
17382 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17383 {
17384 css_cnt_r = 3;
17385 }
17386 else
17387 {
17388 css_cnt_r = 4;
17389 }
17390 }
17391 }
17392 }
17393 else
17394 {
17395 css_cnt_r = 1;
17396
17397 /* unfinished code?
17398 int sum = css_buf[css_cnt_r - 1].cs_len;
17399
17400 for (uint i = 1; i < 4 && i < css_cnt; i++)
17401 {
17402 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17403
17404 css_cnt_r++;
17405
17406 sum *= css_buf[css_cnt_r - 1].cs_len;
17407 }
17408 */
17409 }
17410
17411 css_cnt_l -= css_cnt_r;
17412
17413 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17414
17415 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17416 {
17417 hc_device_param_t *device_param = &data.devices_param[device_id];
17418
17419 if (device_param->skipped) continue;
17420
17421 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17422 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17423 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17424
17425 device_param->kernel_params_mp_l_buf64[3] = 0;
17426 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17427 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17428 device_param->kernel_params_mp_l_buf32[6] = 0;
17429 device_param->kernel_params_mp_l_buf32[7] = 0;
17430 device_param->kernel_params_mp_l_buf32[8] = 0;
17431
17432 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17433 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17434 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17435 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17436
17437 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17438 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17439 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17440
17441 device_param->kernel_params_mp_r_buf64[3] = 0;
17442 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17443 device_param->kernel_params_mp_r_buf32[5] = 0;
17444 device_param->kernel_params_mp_r_buf32[6] = 0;
17445 device_param->kernel_params_mp_r_buf32[7] = 0;
17446
17447 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]);
17448 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]);
17449 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]);
17450
17451 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]);
17452 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]);
17453 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]);
17454
17455 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);
17456 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);
17457 }
17458 }
17459
17460 u64 words_base = data.words_cnt;
17461
17462 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17463 {
17464 if (data.kernel_rules_cnt)
17465 {
17466 words_base /= data.kernel_rules_cnt;
17467 }
17468 }
17469 else if (data.attack_kern == ATTACK_KERN_COMBI)
17470 {
17471 if (data.combs_cnt)
17472 {
17473 words_base /= data.combs_cnt;
17474 }
17475 }
17476 else if (data.attack_kern == ATTACK_KERN_BF)
17477 {
17478 if (data.bfs_cnt)
17479 {
17480 words_base /= data.bfs_cnt;
17481 }
17482 }
17483
17484 data.words_base = words_base;
17485
17486 if (keyspace == 1)
17487 {
17488 log_info ("%llu", (unsigned long long int) words_base);
17489
17490 return (0);
17491 }
17492
17493 if (data.words_cur > data.words_base)
17494 {
17495 log_error ("ERROR: restore value greater keyspace");
17496
17497 return (-1);
17498 }
17499
17500 if (data.words_cur)
17501 {
17502 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17503 {
17504 for (uint i = 0; i < data.salts_cnt; i++)
17505 {
17506 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17507 }
17508 }
17509 else if (data.attack_kern == ATTACK_KERN_COMBI)
17510 {
17511 for (uint i = 0; i < data.salts_cnt; i++)
17512 {
17513 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17514 }
17515 }
17516 else if (data.attack_kern == ATTACK_KERN_BF)
17517 {
17518 for (uint i = 0; i < data.salts_cnt; i++)
17519 {
17520 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17521 }
17522 }
17523 }
17524
17525 /*
17526 * Update loopback file
17527 */
17528
17529 if (loopback == 1)
17530 {
17531 time_t now;
17532
17533 time (&now);
17534
17535 uint random_num = get_random_num (0, 9999);
17536
17537 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17538
17539 data.loopback_file = loopback_file;
17540 }
17541
17542 /*
17543 * Update dictionary statistic
17544 */
17545
17546 if (keyspace == 0)
17547 {
17548 dictstat_fp = fopen (dictstat, "wb");
17549
17550 if (dictstat_fp)
17551 {
17552 lock_file (dictstat_fp);
17553
17554 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17555
17556 fclose (dictstat_fp);
17557 }
17558 }
17559
17560 data.devices_status = STATUS_RUNNING;
17561
17562 if (initial_restore_done == 0)
17563 {
17564 if (data.restore_disable == 0) cycle_restore ();
17565
17566 initial_restore_done = 1;
17567 }
17568
17569 hc_timer_set (&data.timer_running);
17570
17571 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17572 {
17573 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17574 {
17575 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17576 if (quiet == 0) fflush (stdout);
17577 }
17578 }
17579 else if (wordlist_mode == WL_MODE_STDIN)
17580 {
17581 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17582 if (data.quiet == 0) log_info ("");
17583 }
17584
17585 /**
17586 * create autotune threads
17587 */
17588
17589 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17590
17591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17592 {
17593 hc_device_param_t *device_param = &devices_param[device_id];
17594
17595 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17596 }
17597
17598 hc_thread_wait (data.devices_cnt, c_threads);
17599
17600 /*
17601 * Inform user about possible slow speeds
17602 */
17603
17604 uint kernel_power_all = 0;
17605
17606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17607 {
17608 hc_device_param_t *device_param = &devices_param[device_id];
17609
17610 kernel_power_all += device_param->kernel_power;
17611 }
17612
17613 data.kernel_power_all = kernel_power_all;
17614
17615 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17616 {
17617 if (data.words_base < kernel_power_all)
17618 {
17619 if (quiet == 0)
17620 {
17621 log_info ("ATTENTION!");
17622 log_info (" The wordlist or mask you are using is too small.");
17623 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17624 log_info (" The cracking speed will drop.");
17625 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17626 log_info ("");
17627 }
17628 }
17629 }
17630
17631 /**
17632 * create cracker threads
17633 */
17634
17635 time_t runtime_start;
17636
17637 time (&runtime_start);
17638
17639 data.runtime_start = runtime_start;
17640
17641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17642 {
17643 hc_device_param_t *device_param = &devices_param[device_id];
17644
17645 if (wordlist_mode == WL_MODE_STDIN)
17646 {
17647 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17648 }
17649 else
17650 {
17651 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17652 }
17653 }
17654
17655 hc_thread_wait (data.devices_cnt, c_threads);
17656
17657 local_free (c_threads);
17658
17659 data.restore = 0;
17660
17661 // finalize task
17662
17663 logfile_sub_var_uint ("status-after-work", data.devices_status);
17664
17665 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17666
17667 if (data.devices_status == STATUS_CRACKED) break;
17668 if (data.devices_status == STATUS_ABORTED) break;
17669
17670 if (data.devices_status == STATUS_BYPASS)
17671 {
17672 data.devices_status = STATUS_RUNNING;
17673 }
17674
17675 if (induction_dictionaries_cnt)
17676 {
17677 unlink (induction_dictionaries[0]);
17678 }
17679
17680 free (induction_dictionaries);
17681
17682 if (attack_mode != ATTACK_MODE_BF)
17683 {
17684 induction_dictionaries = scan_directory (induction_directory);
17685
17686 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17687 }
17688
17689 if (benchmark == 0)
17690 {
17691 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17692 {
17693 if (quiet == 0) clear_prompt ();
17694
17695 if (quiet == 0) log_info ("");
17696
17697 if (status == 1)
17698 {
17699 status_display ();
17700 }
17701 else
17702 {
17703 if (quiet == 0) status_display ();
17704 }
17705
17706 if (quiet == 0) log_info ("");
17707 }
17708 }
17709
17710 if (attack_mode == ATTACK_MODE_BF)
17711 {
17712 dictpos++;
17713
17714 rd->dictpos = dictpos;
17715 }
17716 else
17717 {
17718 if (induction_dictionaries_cnt)
17719 {
17720 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17721 }
17722 else
17723 {
17724 dictpos++;
17725
17726 rd->dictpos = dictpos;
17727 }
17728 }
17729
17730 time_t runtime_stop;
17731
17732 time (&runtime_stop);
17733
17734 data.runtime_stop = runtime_stop;
17735
17736 logfile_sub_uint (runtime_start);
17737 logfile_sub_uint (runtime_stop);
17738
17739 logfile_sub_msg ("STOP");
17740
17741 global_free (subid);
17742 }
17743
17744 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17745
17746 if (data.devices_status == STATUS_CRACKED) break;
17747 if (data.devices_status == STATUS_ABORTED) break;
17748 if (data.devices_status == STATUS_QUIT) break;
17749
17750 if (data.devices_status == STATUS_BYPASS)
17751 {
17752 data.devices_status = STATUS_RUNNING;
17753 }
17754 }
17755
17756 // 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
17757
17758 if (attack_mode == ATTACK_MODE_STRAIGHT)
17759 {
17760 if (data.wordlist_mode == WL_MODE_FILE)
17761 {
17762 if (data.dictfile == NULL)
17763 {
17764 if (dictfiles != NULL)
17765 {
17766 data.dictfile = dictfiles[0];
17767
17768 hc_timer_set (&data.timer_running);
17769 }
17770 }
17771 }
17772 }
17773 // NOTE: combi is okay because it is already set beforehand
17774 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17775 {
17776 if (data.dictfile == NULL)
17777 {
17778 if (dictfiles != NULL)
17779 {
17780 hc_timer_set (&data.timer_running);
17781
17782 data.dictfile = dictfiles[0];
17783 }
17784 }
17785 }
17786 else if (attack_mode == ATTACK_MODE_BF)
17787 {
17788 if (data.mask == NULL)
17789 {
17790 hc_timer_set (&data.timer_running);
17791
17792 data.mask = masks[0];
17793 }
17794 }
17795
17796 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17797 {
17798 data.devices_status = STATUS_EXHAUSTED;
17799 }
17800
17801 // if cracked / aborted remove last induction dictionary
17802
17803 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17804 {
17805 struct stat induct_stat;
17806
17807 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17808 {
17809 unlink (induction_dictionaries[file_pos]);
17810 }
17811 }
17812
17813 // wait for non-interactive threads
17814
17815 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17816 {
17817 hc_thread_wait (1, &ni_threads[thread_idx]);
17818 }
17819
17820 local_free (ni_threads);
17821
17822 // wait for interactive threads
17823
17824 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17825 {
17826 hc_thread_wait (1, &i_thread);
17827 }
17828
17829 // we dont need restore file anymore
17830 if (data.restore_disable == 0)
17831 {
17832 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17833 {
17834 unlink (eff_restore_file);
17835 unlink (new_restore_file);
17836 }
17837 else
17838 {
17839 cycle_restore ();
17840 }
17841 }
17842
17843 // finally save left hashes
17844
17845 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17846 {
17847 save_hash ();
17848 }
17849
17850 /**
17851 * Clean up
17852 */
17853
17854 if (benchmark == 1)
17855 {
17856 status_benchmark ();
17857
17858 if (machine_readable == 0)
17859 {
17860 log_info ("");
17861 }
17862 }
17863 else
17864 {
17865 if (quiet == 0) clear_prompt ();
17866
17867 if (quiet == 0) log_info ("");
17868
17869 if (status == 1)
17870 {
17871 status_display ();
17872 }
17873 else
17874 {
17875 if (quiet == 0) status_display ();
17876 }
17877
17878 if (quiet == 0) log_info ("");
17879 }
17880
17881 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17882 {
17883 hc_device_param_t *device_param = &data.devices_param[device_id];
17884
17885 if (device_param->skipped) continue;
17886
17887 local_free (device_param->combs_buf);
17888
17889 local_free (device_param->hooks_buf);
17890
17891 local_free (device_param->device_name);
17892
17893 local_free (device_param->device_name_chksum);
17894
17895 local_free (device_param->device_version);
17896
17897 local_free (device_param->driver_version);
17898
17899 if (device_param->pws_buf) myfree (device_param->pws_buf);
17900 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17901 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17902 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17903 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17904 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17905 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17906 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17907 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17908 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17909 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17910 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17911 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17912 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17913 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17914 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17915 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17916 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17917 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17918 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17919 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17920 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17921 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17922 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17923 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17924 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17925 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17926 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17927 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17928
17929 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17930 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17931 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17932 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17933 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17934 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17935 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17936 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17937 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17938 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17939 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17940
17941 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17942 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17943 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17944
17945 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17946 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17947 }
17948
17949 // reset default fan speed
17950
17951 #ifdef HAVE_HWMON
17952 if (gpu_temp_disable == 0)
17953 {
17954 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17955 {
17956 hc_thread_mutex_lock (mux_adl);
17957
17958 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17959 {
17960 hc_device_param_t *device_param = &data.devices_param[device_id];
17961
17962 if (device_param->skipped) continue;
17963
17964 if (data.hm_device[device_id].fan_set_supported == 1)
17965 {
17966 int fanspeed = temp_retain_fanspeed_value[device_id];
17967 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17968
17969 if (fanpolicy == 1)
17970 {
17971 int rc = -1;
17972
17973 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17974 {
17975 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17976 }
17977 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17978 {
17979
17980 }
17981
17982 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17983 }
17984 }
17985 }
17986
17987 hc_thread_mutex_unlock (mux_adl);
17988 }
17989 }
17990
17991 // reset power tuning
17992
17993 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17994 {
17995 hc_thread_mutex_lock (mux_adl);
17996
17997 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17998 {
17999 hc_device_param_t *device_param = &data.devices_param[device_id];
18000
18001 if (device_param->skipped) continue;
18002
18003 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18004 {
18005 if (data.hm_device[device_id].od_version == 6)
18006 {
18007 // check powertune capabilities first, if not available then skip device
18008
18009 int powertune_supported = 0;
18010
18011 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18012 {
18013 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18014
18015 return (-1);
18016 }
18017
18018 if (powertune_supported != 0)
18019 {
18020 // powercontrol settings
18021
18022 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18023 {
18024 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18025
18026 return (-1);
18027 }
18028
18029 // clocks
18030
18031 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18032
18033 performance_state->iNumberOfPerformanceLevels = 2;
18034
18035 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18036 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18037 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18038 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18039
18040 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18041 {
18042 log_info ("ERROR: Failed to restore ADL performance state");
18043
18044 return (-1);
18045 }
18046
18047 local_free (performance_state);
18048 }
18049 }
18050 }
18051
18052 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18053 {
18054 unsigned int limit = nvml_power_limit[device_id];
18055
18056 if (limit > 0)
18057 {
18058 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18059 }
18060 }
18061 }
18062
18063 hc_thread_mutex_unlock (mux_adl);
18064 }
18065
18066 if (gpu_temp_disable == 0)
18067 {
18068 if (data.hm_nvml)
18069 {
18070 hm_NVML_nvmlShutdown (data.hm_nvml);
18071
18072 nvml_close (data.hm_nvml);
18073
18074 data.hm_nvml = NULL;
18075 }
18076
18077 if (data.hm_adl)
18078 {
18079 hm_ADL_Main_Control_Destroy (data.hm_adl);
18080
18081 adl_close (data.hm_adl);
18082
18083 data.hm_adl = NULL;
18084 }
18085 }
18086 #endif // HAVE_HWMON
18087
18088 // free memory
18089
18090 local_free (masks);
18091
18092 local_free (dictstat_base);
18093
18094 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18095 {
18096 pot_t *pot_ptr = &pot[pot_pos];
18097
18098 hash_t *hash = &pot_ptr->hash;
18099
18100 local_free (hash->digest);
18101
18102 if (isSalted)
18103 {
18104 local_free (hash->salt);
18105 }
18106 }
18107
18108 local_free (pot);
18109
18110 local_free (all_kernel_rules_cnt);
18111 local_free (all_kernel_rules_buf);
18112
18113 local_free (wl_data->buf);
18114 local_free (wl_data);
18115
18116 local_free (bitmap_s1_a);
18117 local_free (bitmap_s1_b);
18118 local_free (bitmap_s1_c);
18119 local_free (bitmap_s1_d);
18120 local_free (bitmap_s2_a);
18121 local_free (bitmap_s2_b);
18122 local_free (bitmap_s2_c);
18123 local_free (bitmap_s2_d);
18124
18125 #ifdef HAVE_HWMON
18126 local_free (temp_retain_fanspeed_value);
18127 local_free (od_clock_mem_status);
18128 local_free (od_power_control_status);
18129 local_free (nvml_power_limit);
18130 #endif
18131
18132 global_free (devices_param);
18133
18134 global_free (kernel_rules_buf);
18135
18136 global_free (root_css_buf);
18137 global_free (markov_css_buf);
18138
18139 global_free (digests_buf);
18140 global_free (digests_shown);
18141 global_free (digests_shown_tmp);
18142
18143 global_free (salts_buf);
18144 global_free (salts_shown);
18145
18146 global_free (esalts_buf);
18147
18148 global_free (words_progress_done);
18149 global_free (words_progress_rejected);
18150 global_free (words_progress_restored);
18151
18152 if (pot_fp) fclose (pot_fp);
18153
18154 if (data.devices_status == STATUS_QUIT) break;
18155 }
18156
18157 // destroy others mutex
18158
18159 hc_thread_mutex_delete (mux_dispatcher);
18160 hc_thread_mutex_delete (mux_counter);
18161 hc_thread_mutex_delete (mux_display);
18162 hc_thread_mutex_delete (mux_adl);
18163
18164 // free memory
18165
18166 local_free (eff_restore_file);
18167 local_free (new_restore_file);
18168
18169 local_free (rd);
18170
18171 // tuning db
18172
18173 tuning_db_destroy (tuning_db);
18174
18175 // loopback
18176
18177 local_free (loopback_file);
18178
18179 if (loopback == 1) unlink (loopback_file);
18180
18181 // induction directory
18182
18183 if (induction_dir == NULL)
18184 {
18185 if (attack_mode != ATTACK_MODE_BF)
18186 {
18187 if (rmdir (induction_directory) == -1)
18188 {
18189 if (errno == ENOENT)
18190 {
18191 // good, we can ignore
18192 }
18193 else if (errno == ENOTEMPTY)
18194 {
18195 // good, we can ignore
18196 }
18197 else
18198 {
18199 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18200
18201 return (-1);
18202 }
18203 }
18204
18205 local_free (induction_directory);
18206 }
18207 }
18208
18209 // outfile-check directory
18210
18211 if (outfile_check_dir == NULL)
18212 {
18213 if (rmdir (outfile_check_directory) == -1)
18214 {
18215 if (errno == ENOENT)
18216 {
18217 // good, we can ignore
18218 }
18219 else if (errno == ENOTEMPTY)
18220 {
18221 // good, we can ignore
18222 }
18223 else
18224 {
18225 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18226
18227 return (-1);
18228 }
18229 }
18230
18231 local_free (outfile_check_directory);
18232 }
18233
18234 time_t proc_stop;
18235
18236 time (&proc_stop);
18237
18238 logfile_top_uint (proc_start);
18239 logfile_top_uint (proc_stop);
18240
18241 logfile_top_msg ("STOP");
18242
18243 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18244 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18245
18246 if (data.ocl) ocl_close (data.ocl);
18247
18248 if (data.devices_status == STATUS_ABORTED) return 2;
18249 if (data.devices_status == STATUS_QUIT) return 2;
18250 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18251 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18252 if (data.devices_status == STATUS_CRACKED) return 0;
18253
18254 return -1;
18255 }
Hashcat additions to support pwdhash