projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not show warnings message in case --force is used
[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 (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 ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3898
3899 const int temperature = hm_get_temperature_with_device_id (device_id);
3900
3901 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3902
3903 if (temperature >= threshold)
3904 {
3905 if (slowdown_warnings < 3)
3906 {
3907 if (data.quiet == 0) clear_prompt ();
3908
3909 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3910
3911 if (slowdown_warnings == 2)
3912 {
3913 log_info ("");
3914 }
3915
3916 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3917 if (data.quiet == 0) fflush (stdout);
3918
3919 slowdown_warnings++;
3920 }
3921 }
3922 else
3923 {
3924 slowdown_warnings = 0;
3925 }
3926 }
3927
3928 hc_thread_mutex_unlock (mux_adl);
3929 }
3930
3931 if (hwmon_check == 1)
3932 {
3933 hc_thread_mutex_lock (mux_adl);
3934
3935 time_t temp_check_time;
3936
3937 time (&temp_check_time);
3938
3939 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3940
3941 if (Ta == 0) Ta = 1;
3942
3943 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3944 {
3945 hc_device_param_t *device_param = &data.devices_param[device_id];
3946
3947 if (device_param->skipped) continue;
3948
3949 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3950
3951 const int temperature = hm_get_temperature_with_device_id (device_id);
3952
3953 if (temperature > (int) data.gpu_temp_abort)
3954 {
3955 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3956
3957 if (data.devices_status != STATUS_QUIT) myabort ();
3958
3959 break;
3960 }
3961
3962 const int gpu_temp_retain = data.gpu_temp_retain;
3963
3964 if (gpu_temp_retain)
3965 {
3966 if (data.hm_device[device_id].fan_set_supported == 1)
3967 {
3968 int temp_cur = temperature;
3969
3970 int temp_diff_new = gpu_temp_retain - temp_cur;
3971
3972 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3973
3974 // calculate Ta value (time difference in seconds between the last check and this check)
3975
3976 last_temp_check_time = temp_check_time;
3977
3978 float Kp = 1.8;
3979 float Ki = 0.005;
3980 float Kd = 6;
3981
3982 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3983
3984 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);
3985
3986 if (abs (fan_diff_required) >= temp_threshold)
3987 {
3988 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3989
3990 int fan_speed_level = fan_speed_cur;
3991
3992 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3993
3994 int fan_speed_new = fan_speed_level - fan_diff_required;
3995
3996 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3997 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3998
3999 if (fan_speed_new != fan_speed_cur)
4000 {
4001 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4002 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4003
4004 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4005 {
4006 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4007 {
4008 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4009 }
4010 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4011 {
4012
4013 }
4014
4015 fan_speed_chgd[device_id] = 1;
4016 }
4017
4018 temp_diff_old[device_id] = temp_diff_new;
4019 }
4020 }
4021 }
4022 }
4023 }
4024
4025 hc_thread_mutex_unlock (mux_adl);
4026 }
4027 #endif // HAVE_HWMON
4028
4029 if (restore_check == 1)
4030 {
4031 restore_left--;
4032
4033 if (restore_left == 0)
4034 {
4035 if (data.restore_disable == 0) cycle_restore ();
4036
4037 restore_left = data.restore_timer;
4038 }
4039 }
4040
4041 if ((runtime_check == 1) && (data.runtime_start > 0))
4042 {
4043 time_t runtime_cur;
4044
4045 time (&runtime_cur);
4046
4047 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4048
4049 if (runtime_left <= 0)
4050 {
4051 if (data.benchmark == 0)
4052 {
4053 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4054 }
4055
4056 if (data.devices_status != STATUS_QUIT) myabort ();
4057 }
4058 }
4059
4060 if (remove_check == 1)
4061 {
4062 remove_left--;
4063
4064 if (remove_left == 0)
4065 {
4066 if (data.digests_saved != data.digests_done)
4067 {
4068 data.digests_saved = data.digests_done;
4069
4070 save_hash ();
4071 }
4072
4073 remove_left = data.remove_timer;
4074 }
4075 }
4076
4077 if (status_check == 1)
4078 {
4079 status_left--;
4080
4081 if (status_left == 0)
4082 {
4083 //hc_thread_mutex_lock (mux_display);
4084
4085 if (data.quiet == 0) clear_prompt ();
4086
4087 if (data.quiet == 0) log_info ("");
4088
4089 status_display ();
4090
4091 if (data.quiet == 0) log_info ("");
4092
4093 //hc_thread_mutex_unlock (mux_display);
4094
4095 status_left = data.status_timer;
4096 }
4097 }
4098 }
4099
4100 #ifdef HAVE_HWMON
4101 myfree (fan_speed_chgd);
4102
4103 myfree (temp_diff_old);
4104 myfree (temp_diff_sum);
4105 #endif
4106
4107 p = NULL;
4108
4109 return (p);
4110 }
4111
4112 static void *thread_outfile_remove (void *p)
4113 {
4114 // some hash-dependent constants
4115 char *outfile_dir = data.outfile_check_directory;
4116 uint dgst_size = data.dgst_size;
4117 uint isSalted = data.isSalted;
4118 uint esalt_size = data.esalt_size;
4119 uint hash_mode = data.hash_mode;
4120
4121 uint outfile_check_timer = data.outfile_check_timer;
4122
4123 char separator = data.separator;
4124
4125 // some hash-dependent functions
4126 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4127 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4128
4129 // buffers
4130 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4131
4132 hash_buf.digest = mymalloc (dgst_size);
4133
4134 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4135
4136 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4137
4138 uint digest_buf[64] = { 0 };
4139
4140 outfile_data_t *out_info = NULL;
4141
4142 char **out_files = NULL;
4143
4144 time_t folder_mtime = 0;
4145
4146 int out_cnt = 0;
4147
4148 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4149
4150 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4151 {
4152 hc_sleep (1);
4153
4154 if (data.devices_status != STATUS_RUNNING) continue;
4155
4156 check_left--;
4157
4158 if (check_left == 0)
4159 {
4160 struct stat outfile_check_stat;
4161
4162 if (stat (outfile_dir, &outfile_check_stat) == 0)
4163 {
4164 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4165
4166 if (is_dir == 1)
4167 {
4168 if (outfile_check_stat.st_mtime > folder_mtime)
4169 {
4170 char **out_files_new = scan_directory (outfile_dir);
4171
4172 int out_cnt_new = count_dictionaries (out_files_new);
4173
4174 outfile_data_t *out_info_new = NULL;
4175
4176 if (out_cnt_new > 0)
4177 {
4178 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4179
4180 for (int i = 0; i < out_cnt_new; i++)
4181 {
4182 out_info_new[i].file_name = out_files_new[i];
4183
4184 // check if there are files that we have seen/checked before (and not changed)
4185
4186 for (int j = 0; j < out_cnt; j++)
4187 {
4188 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4189 {
4190 struct stat outfile_stat;
4191
4192 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4193 {
4194 if (outfile_stat.st_ctime == out_info[j].ctime)
4195 {
4196 out_info_new[i].ctime = out_info[j].ctime;
4197 out_info_new[i].seek = out_info[j].seek;
4198 }
4199 }
4200 }
4201 }
4202 }
4203 }
4204
4205 local_free (out_info);
4206 local_free (out_files);
4207
4208 out_files = out_files_new;
4209 out_cnt = out_cnt_new;
4210 out_info = out_info_new;
4211
4212 folder_mtime = outfile_check_stat.st_mtime;
4213 }
4214
4215 for (int j = 0; j < out_cnt; j++)
4216 {
4217 FILE *fp = fopen (out_info[j].file_name, "rb");
4218
4219 if (fp != NULL)
4220 {
4221 //hc_thread_mutex_lock (mux_display);
4222
4223 #ifdef _POSIX
4224 struct stat outfile_stat;
4225
4226 fstat (fileno (fp), &outfile_stat);
4227 #endif
4228
4229 #ifdef _WIN
4230 struct stat64 outfile_stat;
4231
4232 _fstat64 (fileno (fp), &outfile_stat);
4233 #endif
4234
4235 if (outfile_stat.st_ctime > out_info[j].ctime)
4236 {
4237 out_info[j].ctime = outfile_stat.st_ctime;
4238 out_info[j].seek = 0;
4239 }
4240
4241 fseek (fp, out_info[j].seek, SEEK_SET);
4242
4243 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4244
4245 while (!feof (fp))
4246 {
4247 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4248
4249 if (ptr == NULL) break;
4250
4251 int line_len = strlen (line_buf);
4252
4253 if (line_len <= 0) continue;
4254
4255 int iter = MAX_CUT_TRIES;
4256
4257 for (uint i = line_len - 1; i && iter; i--, line_len--)
4258 {
4259 if (line_buf[i] != separator) continue;
4260
4261 int parser_status = PARSER_OK;
4262
4263 if ((hash_mode != 2500) && (hash_mode != 6800))
4264 {
4265 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4266 }
4267
4268 uint found = 0;
4269
4270 if (parser_status == PARSER_OK)
4271 {
4272 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4273 {
4274 if (data.salts_shown[salt_pos] == 1) continue;
4275
4276 salt_t *salt_buf = &data.salts_buf[salt_pos];
4277
4278 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4279 {
4280 uint idx = salt_buf->digests_offset + digest_pos;
4281
4282 if (data.digests_shown[idx] == 1) continue;
4283
4284 uint cracked = 0;
4285
4286 if (hash_mode == 6800)
4287 {
4288 if (i == salt_buf->salt_len)
4289 {
4290 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4291 }
4292 }
4293 else if (hash_mode == 2500)
4294 {
4295 // BSSID : MAC1 : MAC2 (:plain)
4296 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4297 {
4298 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4299
4300 if (!cracked) continue;
4301
4302 // now compare MAC1 and MAC2 too, since we have this additional info
4303 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4304 char *mac2_pos = mac1_pos + 12 + 1;
4305
4306 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4307 wpa_t *wpa = &wpas[salt_pos];
4308
4309 // compare hex string(s) vs binary MAC address(es)
4310
4311 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4312 {
4313 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4314 {
4315 cracked = 0;
4316
4317 break;
4318 }
4319 }
4320
4321 // early skip ;)
4322 if (!cracked) continue;
4323
4324 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4325 {
4326 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4327 {
4328 cracked = 0;
4329
4330 break;
4331 }
4332 }
4333 }
4334 }
4335 else
4336 {
4337 char *digests_buf_ptr = (char *) data.digests_buf;
4338
4339 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4340
4341 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4342 }
4343
4344 if (cracked == 1)
4345 {
4346 found = 1;
4347
4348 data.digests_shown[idx] = 1;
4349
4350 data.digests_done++;
4351
4352 salt_buf->digests_done++;
4353
4354 if (salt_buf->digests_done == salt_buf->digests_cnt)
4355 {
4356 data.salts_shown[salt_pos] = 1;
4357
4358 data.salts_done++;
4359
4360 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4361 }
4362 }
4363 }
4364
4365 if (data.devices_status == STATUS_CRACKED) break;
4366 }
4367 }
4368
4369 if (found) break;
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372
4373 iter--;
4374 }
4375
4376 if (data.devices_status == STATUS_CRACKED) break;
4377 }
4378
4379 myfree (line_buf);
4380
4381 out_info[j].seek = ftell (fp);
4382
4383 //hc_thread_mutex_unlock (mux_display);
4384
4385 fclose (fp);
4386 }
4387 }
4388 }
4389 }
4390
4391 check_left = outfile_check_timer;
4392 }
4393 }
4394
4395 if (esalt_size) local_free (hash_buf.esalt);
4396
4397 if (isSalted) local_free (hash_buf.salt);
4398
4399 local_free (hash_buf.digest);
4400
4401 local_free (out_info);
4402
4403 local_free (out_files);
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4411 {
4412 //if (device_param->pws_cnt < device_param->kernel_power)
4413 //{
4414 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4415
4416 u8 *ptr = (u8 *) pw->i;
4417
4418 memcpy (ptr, pw_buf, pw_len);
4419
4420 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4421
4422 pw->pw_len = pw_len;
4423
4424 device_param->pws_cnt++;
4425 //}
4426 //else
4427 //{
4428 // fprintf (stderr, "BUG pw_add()!!\n");
4429 //
4430 // return;
4431 //}
4432 }
4433
4434 static u32 get_power (const u32 kernel_power)
4435 {
4436 if (data.kernel_power_div)
4437 {
4438 return (float) kernel_power * data.kernel_power_div;
4439 }
4440
4441 return kernel_power;
4442 }
4443
4444 static uint get_work (hc_device_param_t *device_param, const u64 max)
4445 {
4446 hc_thread_mutex_lock (mux_dispatcher);
4447
4448 const u64 words_cur = data.words_cur;
4449 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4450
4451 device_param->words_off = words_cur;
4452
4453 const u64 words_left = words_base - words_cur;
4454
4455 if (data.kernel_power_all > words_left)
4456 {
4457 if (data.kernel_power_div == 0)
4458 {
4459 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4460 }
4461 }
4462
4463 const u32 kernel_power = get_power (device_param->kernel_power);
4464
4465 uint work = MIN (words_left, kernel_power);
4466
4467 work = MIN (work, max);
4468
4469 data.words_cur += work;
4470
4471 hc_thread_mutex_unlock (mux_dispatcher);
4472
4473 return work;
4474 }
4475
4476 static void *thread_autotune (void *p)
4477 {
4478 hc_device_param_t *device_param = (hc_device_param_t *) p;
4479
4480 if (device_param->skipped) return NULL;
4481
4482 autotune (device_param);
4483
4484 return NULL;
4485 }
4486
4487 static void *thread_calc_stdin (void *p)
4488 {
4489 hc_device_param_t *device_param = (hc_device_param_t *) p;
4490
4491 if (device_param->skipped) return NULL;
4492
4493 char *buf = (char *) mymalloc (HCBUFSIZ);
4494
4495 const uint attack_kern = data.attack_kern;
4496
4497 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4498 {
4499 hc_thread_mutex_lock (mux_dispatcher);
4500
4501 if (feof (stdin) != 0)
4502 {
4503 hc_thread_mutex_unlock (mux_dispatcher);
4504
4505 break;
4506 }
4507
4508 uint words_cur = 0;
4509
4510 while (words_cur < get_power (device_param->kernel_power))
4511 {
4512 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4513
4514 if (line_buf == NULL) break;
4515
4516 uint line_len = in_superchop (line_buf);
4517
4518 line_len = convert_from_hex (line_buf, line_len);
4519
4520 // post-process rule engine
4521
4522 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4523 {
4524 char rule_buf_out[BLOCK_SIZE] = { 0 };
4525
4526 int rule_len_out = -1;
4527
4528 if (line_len < BLOCK_SIZE)
4529 {
4530 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4531 }
4532
4533 if (rule_len_out < 0) continue;
4534
4535 line_buf = rule_buf_out;
4536 line_len = rule_len_out;
4537 }
4538
4539 if (line_len > PW_MAX)
4540 {
4541 continue;
4542 }
4543
4544 if (attack_kern == ATTACK_KERN_STRAIGHT)
4545 {
4546 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4547 {
4548 hc_thread_mutex_lock (mux_counter);
4549
4550 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4551 {
4552 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4553 }
4554
4555 hc_thread_mutex_unlock (mux_counter);
4556
4557 continue;
4558 }
4559 }
4560 else if (attack_kern == ATTACK_KERN_COMBI)
4561 {
4562 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4563 // since we still need to combine the plains
4564
4565 if (line_len > data.pw_max)
4566 {
4567 hc_thread_mutex_lock (mux_counter);
4568
4569 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4570 {
4571 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4572 }
4573
4574 hc_thread_mutex_unlock (mux_counter);
4575
4576 continue;
4577 }
4578 }
4579
4580 pw_add (device_param, (u8 *) line_buf, line_len);
4581
4582 words_cur++;
4583
4584 if (data.devices_status == STATUS_CRACKED) break;
4585 if (data.devices_status == STATUS_ABORTED) break;
4586 if (data.devices_status == STATUS_QUIT) break;
4587 if (data.devices_status == STATUS_BYPASS) break;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_dispatcher);
4591
4592 if (data.devices_status == STATUS_CRACKED) break;
4593 if (data.devices_status == STATUS_ABORTED) break;
4594 if (data.devices_status == STATUS_QUIT) break;
4595 if (data.devices_status == STATUS_BYPASS) break;
4596
4597 // flush
4598
4599 const uint pws_cnt = device_param->pws_cnt;
4600
4601 if (pws_cnt)
4602 {
4603 run_copy (device_param, pws_cnt);
4604
4605 run_cracker (device_param, pws_cnt);
4606
4607 device_param->pws_cnt = 0;
4608
4609 /*
4610 still required?
4611 if (attack_kern == ATTACK_KERN_STRAIGHT)
4612 {
4613 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4614 }
4615 else if (attack_kern == ATTACK_KERN_COMBI)
4616 {
4617 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4618 }
4619 */
4620 }
4621 }
4622
4623 device_param->kernel_accel = 0;
4624 device_param->kernel_loops = 0;
4625
4626 myfree (buf);
4627
4628 return NULL;
4629 }
4630
4631 static void *thread_calc (void *p)
4632 {
4633 hc_device_param_t *device_param = (hc_device_param_t *) p;
4634
4635 if (device_param->skipped) return NULL;
4636
4637 const uint attack_mode = data.attack_mode;
4638 const uint attack_kern = data.attack_kern;
4639
4640 if (attack_mode == ATTACK_MODE_BF)
4641 {
4642 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4643 {
4644 const uint work = get_work (device_param, -1);
4645
4646 if (work == 0) break;
4647
4648 const u64 words_off = device_param->words_off;
4649 const u64 words_fin = words_off + work;
4650
4651 const uint pws_cnt = work;
4652
4653 device_param->pws_cnt = pws_cnt;
4654
4655 if (pws_cnt)
4656 {
4657 run_copy (device_param, pws_cnt);
4658
4659 run_cracker (device_param, pws_cnt);
4660
4661 device_param->pws_cnt = 0;
4662
4663 /*
4664 still required?
4665 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4666 */
4667 }
4668
4669 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4670
4671 if (data.devices_status == STATUS_CRACKED) break;
4672 if (data.devices_status == STATUS_ABORTED) break;
4673 if (data.devices_status == STATUS_QUIT) break;
4674 if (data.devices_status == STATUS_BYPASS) break;
4675
4676 if (data.benchmark == 1) break;
4677
4678 device_param->words_done = words_fin;
4679 }
4680 }
4681 else
4682 {
4683 const uint segment_size = data.segment_size;
4684
4685 char *dictfile = data.dictfile;
4686
4687 if (attack_mode == ATTACK_MODE_COMBI)
4688 {
4689 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4690 {
4691 dictfile = data.dictfile2;
4692 }
4693 }
4694
4695 FILE *fd = fopen (dictfile, "rb");
4696
4697 if (fd == NULL)
4698 {
4699 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4700
4701 return NULL;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 const uint combs_mode = data.combs_mode;
4707
4708 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4709 {
4710 const char *dictfilec = data.dictfile2;
4711
4712 FILE *combs_fp = fopen (dictfilec, "rb");
4713
4714 if (combs_fp == NULL)
4715 {
4716 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4717
4718 fclose (fd);
4719
4720 return NULL;
4721 }
4722
4723 device_param->combs_fp = combs_fp;
4724 }
4725 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4726 {
4727 const char *dictfilec = data.dictfile;
4728
4729 FILE *combs_fp = fopen (dictfilec, "rb");
4730
4731 if (combs_fp == NULL)
4732 {
4733 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4734
4735 fclose (fd);
4736
4737 return NULL;
4738 }
4739
4740 device_param->combs_fp = combs_fp;
4741 }
4742 }
4743
4744 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4745
4746 wl_data->buf = (char *) mymalloc (segment_size);
4747 wl_data->avail = segment_size;
4748 wl_data->incr = segment_size;
4749 wl_data->cnt = 0;
4750 wl_data->pos = 0;
4751
4752 u64 words_cur = 0;
4753
4754 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4755 {
4756 u64 words_off = 0;
4757 u64 words_fin = 0;
4758
4759 u64 max = -1;
4760
4761 while (max)
4762 {
4763 const uint work = get_work (device_param, max);
4764
4765 if (work == 0) break;
4766
4767 max = 0;
4768
4769 words_off = device_param->words_off;
4770 words_fin = words_off + work;
4771
4772 char *line_buf;
4773 uint line_len;
4774
4775 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4776
4777 for ( ; words_cur < words_fin; words_cur++)
4778 {
4779 get_next_word (wl_data, fd, &line_buf, &line_len);
4780
4781 line_len = convert_from_hex (line_buf, line_len);
4782
4783 // post-process rule engine
4784
4785 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4786 {
4787 char rule_buf_out[BLOCK_SIZE] = { 0 };
4788
4789 int rule_len_out = -1;
4790
4791 if (line_len < BLOCK_SIZE)
4792 {
4793 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4794 }
4795
4796 if (rule_len_out < 0) continue;
4797
4798 line_buf = rule_buf_out;
4799 line_len = rule_len_out;
4800 }
4801
4802 if (attack_kern == ATTACK_KERN_STRAIGHT)
4803 {
4804 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4805 {
4806 max++;
4807
4808 hc_thread_mutex_lock (mux_counter);
4809
4810 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4811 {
4812 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4813 }
4814
4815 hc_thread_mutex_unlock (mux_counter);
4816
4817 continue;
4818 }
4819 }
4820 else if (attack_kern == ATTACK_KERN_COMBI)
4821 {
4822 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4823 // since we still need to combine the plains
4824
4825 if (line_len > data.pw_max)
4826 {
4827 max++;
4828
4829 hc_thread_mutex_lock (mux_counter);
4830
4831 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4832 {
4833 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4834 }
4835
4836 hc_thread_mutex_unlock (mux_counter);
4837
4838 continue;
4839 }
4840 }
4841
4842 pw_add (device_param, (u8 *) line_buf, line_len);
4843
4844 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4845
4846 if (data.devices_status == STATUS_CRACKED) break;
4847 if (data.devices_status == STATUS_ABORTED) break;
4848 if (data.devices_status == STATUS_QUIT) break;
4849 if (data.devices_status == STATUS_BYPASS) break;
4850 }
4851
4852 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4853
4854 if (data.devices_status == STATUS_CRACKED) break;
4855 if (data.devices_status == STATUS_ABORTED) break;
4856 if (data.devices_status == STATUS_QUIT) break;
4857 if (data.devices_status == STATUS_BYPASS) break;
4858 }
4859
4860 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4861
4862 if (data.devices_status == STATUS_CRACKED) break;
4863 if (data.devices_status == STATUS_ABORTED) break;
4864 if (data.devices_status == STATUS_QUIT) break;
4865 if (data.devices_status == STATUS_BYPASS) break;
4866
4867 //
4868 // flush
4869 //
4870
4871 const uint pws_cnt = device_param->pws_cnt;
4872
4873 if (pws_cnt)
4874 {
4875 run_copy (device_param, pws_cnt);
4876
4877 run_cracker (device_param, pws_cnt);
4878
4879 device_param->pws_cnt = 0;
4880
4881 /*
4882 still required?
4883 if (attack_kern == ATTACK_KERN_STRAIGHT)
4884 {
4885 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4886 }
4887 else if (attack_kern == ATTACK_KERN_COMBI)
4888 {
4889 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4890 }
4891 */
4892 }
4893
4894 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900
4901 if (words_fin == 0) break;
4902
4903 device_param->words_done = words_fin;
4904 }
4905
4906 if (attack_mode == ATTACK_MODE_COMBI)
4907 {
4908 fclose (device_param->combs_fp);
4909 }
4910
4911 free (wl_data->buf);
4912 free (wl_data);
4913
4914 fclose (fd);
4915 }
4916
4917 device_param->kernel_accel = 0;
4918 device_param->kernel_loops = 0;
4919
4920 return NULL;
4921 }
4922
4923 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4924 {
4925 if (!device_param)
4926 {
4927 log_error ("ERROR: %s : Invalid argument", __func__);
4928
4929 exit (-1);
4930 }
4931
4932 salt_t *salt_buf = &data.salts_buf[salt_pos];
4933
4934 device_param->kernel_params_buf32[24] = salt_pos;
4935 device_param->kernel_params_buf32[27] = 1;
4936 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4937 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4938 device_param->kernel_params_buf32[30] = 0;
4939 device_param->kernel_params_buf32[31] = 1;
4940
4941 char *dictfile_old = data.dictfile;
4942
4943 const char *weak_hash_check = "weak-hash-check";
4944
4945 data.dictfile = (char *) weak_hash_check;
4946
4947 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4948
4949 data.kernel_rules_buf[0].cmds[0] = 0;
4950
4951 /**
4952 * run the kernel
4953 */
4954
4955 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4956 {
4957 run_kernel (KERN_RUN_1, device_param, 1, false);
4958 }
4959 else
4960 {
4961 run_kernel (KERN_RUN_1, device_param, 1, false);
4962
4963 uint loop_step = 16;
4964
4965 const uint iter = salt_buf->salt_iter;
4966
4967 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4968 {
4969 uint loop_left = iter - loop_pos;
4970
4971 loop_left = MIN (loop_left, loop_step);
4972
4973 device_param->kernel_params_buf32[25] = loop_pos;
4974 device_param->kernel_params_buf32[26] = loop_left;
4975
4976 run_kernel (KERN_RUN_2, device_param, 1, false);
4977 }
4978
4979 run_kernel (KERN_RUN_3, device_param, 1, false);
4980 }
4981
4982 /**
4983 * result
4984 */
4985
4986 check_cracked (device_param, salt_pos);
4987
4988 /**
4989 * cleanup
4990 */
4991
4992 device_param->kernel_params_buf32[24] = 0;
4993 device_param->kernel_params_buf32[25] = 0;
4994 device_param->kernel_params_buf32[26] = 0;
4995 device_param->kernel_params_buf32[27] = 0;
4996 device_param->kernel_params_buf32[28] = 0;
4997 device_param->kernel_params_buf32[29] = 0;
4998 device_param->kernel_params_buf32[30] = 0;
4999 device_param->kernel_params_buf32[31] = 0;
5000
5001 data.dictfile = dictfile_old;
5002
5003 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5004 }
5005
5006 // hlfmt hashcat
5007
5008 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5009 {
5010 if (data.username == 0)
5011 {
5012 *hashbuf_pos = line_buf;
5013 *hashbuf_len = line_len;
5014 }
5015 else
5016 {
5017 char *pos = line_buf;
5018 int len = line_len;
5019
5020 for (int i = 0; i < line_len; i++, pos++, len--)
5021 {
5022 if (line_buf[i] == data.separator)
5023 {
5024 pos++;
5025
5026 len--;
5027
5028 break;
5029 }
5030 }
5031
5032 *hashbuf_pos = pos;
5033 *hashbuf_len = len;
5034 }
5035 }
5036
5037 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5038 {
5039 char *pos = NULL;
5040 int len = 0;
5041
5042 int sep_cnt = 0;
5043
5044 for (int i = 0; i < line_len; i++)
5045 {
5046 if (line_buf[i] == data.separator)
5047 {
5048 sep_cnt++;
5049
5050 continue;
5051 }
5052
5053 if (sep_cnt == 0)
5054 {
5055 if (pos == NULL) pos = line_buf + i;
5056
5057 len++;
5058 }
5059 }
5060
5061 *userbuf_pos = pos;
5062 *userbuf_len = len;
5063 }
5064
5065 // hlfmt pwdump
5066
5067 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5068 {
5069 int sep_cnt = 0;
5070
5071 int sep2_len = 0;
5072 int sep3_len = 0;
5073
5074 for (int i = 0; i < line_len; i++)
5075 {
5076 if (line_buf[i] == ':')
5077 {
5078 sep_cnt++;
5079
5080 continue;
5081 }
5082
5083 if (sep_cnt == 2) sep2_len++;
5084 if (sep_cnt == 3) sep3_len++;
5085 }
5086
5087 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5088
5089 return 0;
5090 }
5091
5092 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5093 {
5094 char *pos = NULL;
5095 int len = 0;
5096
5097 int sep_cnt = 0;
5098
5099 for (int i = 0; i < line_len; i++)
5100 {
5101 if (line_buf[i] == ':')
5102 {
5103 sep_cnt++;
5104
5105 continue;
5106 }
5107
5108 if (data.hash_mode == 1000)
5109 {
5110 if (sep_cnt == 3)
5111 {
5112 if (pos == NULL) pos = line_buf + i;
5113
5114 len++;
5115 }
5116 }
5117 else if (data.hash_mode == 3000)
5118 {
5119 if (sep_cnt == 2)
5120 {
5121 if (pos == NULL) pos = line_buf + i;
5122
5123 len++;
5124 }
5125 }
5126 }
5127
5128 *hashbuf_pos = pos;
5129 *hashbuf_len = len;
5130 }
5131
5132 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5133 {
5134 char *pos = NULL;
5135 int len = 0;
5136
5137 int sep_cnt = 0;
5138
5139 for (int i = 0; i < line_len; i++)
5140 {
5141 if (line_buf[i] == ':')
5142 {
5143 sep_cnt++;
5144
5145 continue;
5146 }
5147
5148 if (sep_cnt == 0)
5149 {
5150 if (pos == NULL) pos = line_buf + i;
5151
5152 len++;
5153 }
5154 }
5155
5156 *userbuf_pos = pos;
5157 *userbuf_len = len;
5158 }
5159
5160 // hlfmt passwd
5161
5162 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5163 {
5164 int sep_cnt = 0;
5165
5166 char sep5_first = 0;
5167 char sep6_first = 0;
5168
5169 for (int i = 0; i < line_len; i++)
5170 {
5171 if (line_buf[i] == ':')
5172 {
5173 sep_cnt++;
5174
5175 continue;
5176 }
5177
5178 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5179 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5180 }
5181
5182 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5183
5184 return 0;
5185 }
5186
5187 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5188 {
5189 char *pos = NULL;
5190 int len = 0;
5191
5192 int sep_cnt = 0;
5193
5194 for (int i = 0; i < line_len; i++)
5195 {
5196 if (line_buf[i] == ':')
5197 {
5198 sep_cnt++;
5199
5200 continue;
5201 }
5202
5203 if (sep_cnt == 1)
5204 {
5205 if (pos == NULL) pos = line_buf + i;
5206
5207 len++;
5208 }
5209 }
5210
5211 *hashbuf_pos = pos;
5212 *hashbuf_len = len;
5213 }
5214
5215 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5216 {
5217 char *pos = NULL;
5218 int len = 0;
5219
5220 int sep_cnt = 0;
5221
5222 for (int i = 0; i < line_len; i++)
5223 {
5224 if (line_buf[i] == ':')
5225 {
5226 sep_cnt++;
5227
5228 continue;
5229 }
5230
5231 if (sep_cnt == 0)
5232 {
5233 if (pos == NULL) pos = line_buf + i;
5234
5235 len++;
5236 }
5237 }
5238
5239 *userbuf_pos = pos;
5240 *userbuf_len = len;
5241 }
5242
5243 // hlfmt shadow
5244
5245 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5246 {
5247 int sep_cnt = 0;
5248
5249 for (int i = 0; i < line_len; i++)
5250 {
5251 if (line_buf[i] == ':') sep_cnt++;
5252 }
5253
5254 if (sep_cnt == 8) return 1;
5255
5256 return 0;
5257 }
5258
5259 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5260 {
5261 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5262 }
5263
5264 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5265 {
5266 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5267 }
5268
5269 // hlfmt main
5270
5271 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5272 {
5273 switch (hashfile_format)
5274 {
5275 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5276 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5277 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5278 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5279 }
5280 }
5281
5282 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5283 {
5284 switch (hashfile_format)
5285 {
5286 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5287 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5288 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5289 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5290 }
5291 }
5292
5293 char *strhlfmt (const uint hashfile_format)
5294 {
5295 switch (hashfile_format)
5296 {
5297 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5298 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5299 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5300 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5301 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5302 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5303 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5304 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5305 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5306 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5307 }
5308
5309 return ((char *) "Unknown");
5310 }
5311
5312 static uint hlfmt_detect (FILE *fp, uint max_check)
5313 {
5314 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5315
5316 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5317 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5318
5319 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5320
5321 uint num_check = 0;
5322
5323 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5324
5325 while (!feof (fp))
5326 {
5327 int line_len = fgetl (fp, line_buf);
5328
5329 if (line_len == 0) continue;
5330
5331 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5332 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5333 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5334
5335 if (num_check == max_check) break;
5336
5337 num_check++;
5338 }
5339
5340 myfree (line_buf);
5341
5342 uint hashlist_format = HLFMT_HASHCAT;
5343
5344 for (int i = 1; i < HLFMTS_CNT; i++)
5345 {
5346 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5347
5348 hashlist_format = i;
5349 }
5350
5351 free (formats_cnt);
5352
5353 return hashlist_format;
5354 }
5355
5356 /**
5357 * some further helper function
5358 */
5359
5360 // wrapper around mymalloc for ADL
5361
5362 #if defined(HAVE_HWMON)
5363 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5364 {
5365 return mymalloc (iSize);
5366 }
5367 #endif
5368
5369 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)
5370 {
5371 u64 collisions = 0;
5372
5373 const uint dgst_pos0 = data.dgst_pos0;
5374 const uint dgst_pos1 = data.dgst_pos1;
5375 const uint dgst_pos2 = data.dgst_pos2;
5376 const uint dgst_pos3 = data.dgst_pos3;
5377
5378 memset (bitmap_a, 0, bitmap_size);
5379 memset (bitmap_b, 0, bitmap_size);
5380 memset (bitmap_c, 0, bitmap_size);
5381 memset (bitmap_d, 0, bitmap_size);
5382
5383 for (uint i = 0; i < digests_cnt; i++)
5384 {
5385 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5386
5387 uint *digest_ptr = (uint *) digests_buf_ptr;
5388
5389 digests_buf_ptr += dgst_size;
5390
5391 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5392 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5393 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5394 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5395
5396 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5397 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5398 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5399 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5400
5401 if (bitmap_a[idx0] & val0) collisions++;
5402 if (bitmap_b[idx1] & val1) collisions++;
5403 if (bitmap_c[idx2] & val2) collisions++;
5404 if (bitmap_d[idx3] & val3) collisions++;
5405
5406 bitmap_a[idx0] |= val0;
5407 bitmap_b[idx1] |= val1;
5408 bitmap_c[idx2] |= val2;
5409 bitmap_d[idx3] |= val3;
5410
5411 if (collisions >= collisions_max) return 0x7fffffff;
5412 }
5413
5414 return collisions;
5415 }
5416
5417 /**
5418 * main
5419 */
5420
5421 #ifdef _WIN
5422 void SetConsoleWindowSize (const int x)
5423 {
5424 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5425
5426 if (h == INVALID_HANDLE_VALUE) return;
5427
5428 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5429
5430 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5431
5432 SMALL_RECT *sr = &bufferInfo.srWindow;
5433
5434 sr->Right = MAX (sr->Right, x - 1);
5435
5436 COORD co;
5437
5438 co.X = sr->Right + 1;
5439 co.Y = sr->Bottom + 1;
5440
5441 if (!SetConsoleScreenBufferSize (h, co)) return;
5442
5443 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5444 }
5445 #endif
5446
5447 int main (int argc, char **argv)
5448 {
5449 #ifdef _WIN
5450 SetConsoleWindowSize (132);
5451 #endif
5452
5453 /**
5454 * To help users a bit
5455 */
5456
5457 char *compute = getenv ("COMPUTE");
5458
5459 if (compute)
5460 {
5461 static char display[100];
5462
5463 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5464
5465 putenv (display);
5466 }
5467 else
5468 {
5469 if (getenv ("DISPLAY") == NULL)
5470 putenv ((char *) "DISPLAY=:0");
5471 }
5472
5473 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5474 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5475
5476 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5477 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5478
5479 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5480 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5481
5482 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5483 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5484
5485 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5486 putenv ((char *) "POCL_KERNEL_CACHE=0");
5487
5488 umask (077);
5489
5490 /**
5491 * Real init
5492 */
5493
5494 memset (&data, 0, sizeof (hc_global_data_t));
5495
5496 time_t proc_start;
5497
5498 time (&proc_start);
5499
5500 data.proc_start = proc_start;
5501
5502 int myargc = argc;
5503 char **myargv = argv;
5504
5505 hc_thread_mutex_init (mux_dispatcher);
5506 hc_thread_mutex_init (mux_counter);
5507 hc_thread_mutex_init (mux_display);
5508 hc_thread_mutex_init (mux_adl);
5509
5510 /**
5511 * commandline parameters
5512 */
5513
5514 uint usage = USAGE;
5515 uint version = VERSION;
5516 uint quiet = QUIET;
5517 uint benchmark = BENCHMARK;
5518 uint show = SHOW;
5519 uint left = LEFT;
5520 uint username = USERNAME;
5521 uint remove = REMOVE;
5522 uint remove_timer = REMOVE_TIMER;
5523 u64 skip = SKIP;
5524 u64 limit = LIMIT;
5525 uint keyspace = KEYSPACE;
5526 uint potfile_disable = POTFILE_DISABLE;
5527 char *potfile_path = NULL;
5528 uint debug_mode = DEBUG_MODE;
5529 char *debug_file = NULL;
5530 char *induction_dir = NULL;
5531 char *outfile_check_dir = NULL;
5532 uint force = FORCE;
5533 uint runtime = RUNTIME;
5534 uint hash_mode = HASH_MODE;
5535 uint attack_mode = ATTACK_MODE;
5536 uint markov_disable = MARKOV_DISABLE;
5537 uint markov_classic = MARKOV_CLASSIC;
5538 uint markov_threshold = MARKOV_THRESHOLD;
5539 char *markov_hcstat = NULL;
5540 char *outfile = NULL;
5541 uint outfile_format = OUTFILE_FORMAT;
5542 uint outfile_autohex = OUTFILE_AUTOHEX;
5543 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5544 uint restore = RESTORE;
5545 uint restore_timer = RESTORE_TIMER;
5546 uint restore_disable = RESTORE_DISABLE;
5547 uint status = STATUS;
5548 uint status_timer = STATUS_TIMER;
5549 uint machine_readable = MACHINE_READABLE;
5550 uint loopback = LOOPBACK;
5551 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5552 char *session = NULL;
5553 uint hex_charset = HEX_CHARSET;
5554 uint hex_salt = HEX_SALT;
5555 uint hex_wordlist = HEX_WORDLIST;
5556 uint rp_gen = RP_GEN;
5557 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5558 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5559 uint rp_gen_seed = RP_GEN_SEED;
5560 char *rule_buf_l = (char *) RULE_BUF_L;
5561 char *rule_buf_r = (char *) RULE_BUF_R;
5562 uint increment = INCREMENT;
5563 uint increment_min = INCREMENT_MIN;
5564 uint increment_max = INCREMENT_MAX;
5565 char *cpu_affinity = NULL;
5566 OCL_PTR *ocl = NULL;
5567 char *opencl_devices = NULL;
5568 char *opencl_platforms = NULL;
5569 char *opencl_device_types = NULL;
5570 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5571 char *truecrypt_keyfiles = NULL;
5572 char *veracrypt_keyfiles = NULL;
5573 uint veracrypt_pim = 0;
5574 uint workload_profile = WORKLOAD_PROFILE;
5575 uint kernel_accel = KERNEL_ACCEL;
5576 uint kernel_loops = KERNEL_LOOPS;
5577 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5578 #ifdef HAVE_HWMON
5579 uint gpu_temp_abort = GPU_TEMP_ABORT;
5580 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5581 uint powertune_enable = POWERTUNE_ENABLE;
5582 #endif
5583 uint logfile_disable = LOGFILE_DISABLE;
5584 uint segment_size = SEGMENT_SIZE;
5585 uint scrypt_tmto = SCRYPT_TMTO;
5586 char separator = SEPARATOR;
5587 uint bitmap_min = BITMAP_MIN;
5588 uint bitmap_max = BITMAP_MAX;
5589 char *custom_charset_1 = NULL;
5590 char *custom_charset_2 = NULL;
5591 char *custom_charset_3 = NULL;
5592 char *custom_charset_4 = NULL;
5593
5594 #define IDX_HELP 'h'
5595 #define IDX_VERSION 'V'
5596 #define IDX_VERSION_LOWER 'v'
5597 #define IDX_QUIET 0xff02
5598 #define IDX_SHOW 0xff03
5599 #define IDX_LEFT 0xff04
5600 #define IDX_REMOVE 0xff05
5601 #define IDX_REMOVE_TIMER 0xff37
5602 #define IDX_SKIP 's'
5603 #define IDX_LIMIT 'l'
5604 #define IDX_KEYSPACE 0xff35
5605 #define IDX_POTFILE_DISABLE 0xff06
5606 #define IDX_POTFILE_PATH 0xffe0
5607 #define IDX_DEBUG_MODE 0xff43
5608 #define IDX_DEBUG_FILE 0xff44
5609 #define IDX_INDUCTION_DIR 0xff46
5610 #define IDX_OUTFILE_CHECK_DIR 0xff47
5611 #define IDX_USERNAME 0xff07
5612 #define IDX_FORCE 0xff08
5613 #define IDX_RUNTIME 0xff09
5614 #define IDX_BENCHMARK 'b'
5615 #define IDX_HASH_MODE 'm'
5616 #define IDX_ATTACK_MODE 'a'
5617 #define IDX_RP_FILE 'r'
5618 #define IDX_RP_GEN 'g'
5619 #define IDX_RP_GEN_FUNC_MIN 0xff10
5620 #define IDX_RP_GEN_FUNC_MAX 0xff11
5621 #define IDX_RP_GEN_SEED 0xff34
5622 #define IDX_RULE_BUF_L 'j'
5623 #define IDX_RULE_BUF_R 'k'
5624 #define IDX_INCREMENT 'i'
5625 #define IDX_INCREMENT_MIN 0xff12
5626 #define IDX_INCREMENT_MAX 0xff13
5627 #define IDX_OUTFILE 'o'
5628 #define IDX_OUTFILE_FORMAT 0xff14
5629 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5630 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5631 #define IDX_RESTORE 0xff15
5632 #define IDX_RESTORE_DISABLE 0xff27
5633 #define IDX_STATUS 0xff17
5634 #define IDX_STATUS_TIMER 0xff18
5635 #define IDX_MACHINE_READABLE 0xff50
5636 #define IDX_LOOPBACK 0xff38
5637 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5638 #define IDX_SESSION 0xff19
5639 #define IDX_HEX_CHARSET 0xff20
5640 #define IDX_HEX_SALT 0xff21
5641 #define IDX_HEX_WORDLIST 0xff40
5642 #define IDX_MARKOV_DISABLE 0xff22
5643 #define IDX_MARKOV_CLASSIC 0xff23
5644 #define IDX_MARKOV_THRESHOLD 't'
5645 #define IDX_MARKOV_HCSTAT 0xff24
5646 #define IDX_CPU_AFFINITY 0xff25
5647 #define IDX_OPENCL_DEVICES 'd'
5648 #define IDX_OPENCL_PLATFORMS 0xff72
5649 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5650 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5651 #define IDX_WORKLOAD_PROFILE 'w'
5652 #define IDX_KERNEL_ACCEL 'n'
5653 #define IDX_KERNEL_LOOPS 'u'
5654 #define IDX_GPU_TEMP_DISABLE 0xff29
5655 #define IDX_GPU_TEMP_ABORT 0xff30
5656 #define IDX_GPU_TEMP_RETAIN 0xff31
5657 #define IDX_POWERTUNE_ENABLE 0xff41
5658 #define IDX_LOGFILE_DISABLE 0xff51
5659 #define IDX_TRUECRYPT_KEYFILES 0xff52
5660 #define IDX_VERACRYPT_KEYFILES 0xff53
5661 #define IDX_VERACRYPT_PIM 0xff54
5662 #define IDX_SCRYPT_TMTO 0xff61
5663 #define IDX_SEGMENT_SIZE 'c'
5664 #define IDX_SEPARATOR 'p'
5665 #define IDX_BITMAP_MIN 0xff70
5666 #define IDX_BITMAP_MAX 0xff71
5667 #define IDX_CUSTOM_CHARSET_1 '1'
5668 #define IDX_CUSTOM_CHARSET_2 '2'
5669 #define IDX_CUSTOM_CHARSET_3 '3'
5670 #define IDX_CUSTOM_CHARSET_4 '4'
5671
5672 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5673
5674 struct option long_options[] =
5675 {
5676 {"help", no_argument, 0, IDX_HELP},
5677 {"version", no_argument, 0, IDX_VERSION},
5678 {"quiet", no_argument, 0, IDX_QUIET},
5679 {"show", no_argument, 0, IDX_SHOW},
5680 {"left", no_argument, 0, IDX_LEFT},
5681 {"username", no_argument, 0, IDX_USERNAME},
5682 {"remove", no_argument, 0, IDX_REMOVE},
5683 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5684 {"skip", required_argument, 0, IDX_SKIP},
5685 {"limit", required_argument, 0, IDX_LIMIT},
5686 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5687 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5688 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5689 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5690 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5691 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5692 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5693 {"force", no_argument, 0, IDX_FORCE},
5694 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5695 {"restore", no_argument, 0, IDX_RESTORE},
5696 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5697 {"status", no_argument, 0, IDX_STATUS},
5698 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5699 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5700 {"loopback", no_argument, 0, IDX_LOOPBACK},
5701 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5702 {"session", required_argument, 0, IDX_SESSION},
5703 {"runtime", required_argument, 0, IDX_RUNTIME},
5704 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5705 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5706 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5707 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5708 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5709 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5710 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5711 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5712 {"rules-file", required_argument, 0, IDX_RP_FILE},
5713 {"outfile", required_argument, 0, IDX_OUTFILE},
5714 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5715 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5716 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5717 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5718 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5719 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5720 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5721 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5722 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5723 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5724 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5725 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5726 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5727 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5728 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5729 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5730 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5731 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5732 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5733 #ifdef HAVE_HWMON
5734 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5735 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5736 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5737 #endif // HAVE_HWMON
5738 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5739 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5740 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5741 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5742 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5743 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5744 {"seperator", required_argument, 0, IDX_SEPARATOR},
5745 {"separator", required_argument, 0, IDX_SEPARATOR},
5746 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5747 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5748 {"increment", no_argument, 0, IDX_INCREMENT},
5749 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5750 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5751 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5752 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5753 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5754 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5755 {0, 0, 0, 0}
5756 };
5757
5758 uint rp_files_cnt = 0;
5759
5760 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5761
5762 int option_index = 0;
5763 int c = -1;
5764
5765 optind = 1;
5766 optopt = 0;
5767
5768 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5769 {
5770 switch (c)
5771 {
5772 case IDX_HELP: usage = 1; break;
5773 case IDX_VERSION:
5774 case IDX_VERSION_LOWER: version = 1; break;
5775 case IDX_RESTORE: restore = 1; break;
5776 case IDX_SESSION: session = optarg; break;
5777 case IDX_SHOW: show = 1; break;
5778 case IDX_LEFT: left = 1; break;
5779 case '?': return (-1);
5780 }
5781 }
5782
5783 if (optopt != 0)
5784 {
5785 log_error ("ERROR: Invalid argument specified");
5786
5787 return (-1);
5788 }
5789
5790 /**
5791 * exit functions
5792 */
5793
5794 if (version)
5795 {
5796 log_info ("%s", VERSION_TAG);
5797
5798 return (0);
5799 }
5800
5801 if (usage)
5802 {
5803 usage_big_print (PROGNAME);
5804
5805 return (0);
5806 }
5807
5808 /**
5809 * session needs to be set, always!
5810 */
5811
5812 if (session == NULL) session = (char *) PROGNAME;
5813
5814 /**
5815 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5816 */
5817
5818 char *exec_path = get_exec_path ();
5819
5820 #ifdef LINUX
5821
5822 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5823 char *resolved_exec_path = realpath (exec_path, NULL);
5824
5825 char *install_dir = get_install_dir (resolved_exec_path);
5826 char *profile_dir = NULL;
5827 char *session_dir = NULL;
5828 char *shared_dir = NULL;
5829
5830 if (strcmp (install_dir, resolved_install_folder) == 0)
5831 {
5832 struct passwd *pw = getpwuid (getuid ());
5833
5834 const char *homedir = pw->pw_dir;
5835
5836 profile_dir = get_profile_dir (homedir);
5837 session_dir = get_session_dir (profile_dir);
5838 shared_dir = strdup (SHARED_FOLDER);
5839
5840 mkdir (profile_dir, 0700);
5841 mkdir (session_dir, 0700);
5842 }
5843 else
5844 {
5845 profile_dir = install_dir;
5846 session_dir = install_dir;
5847 shared_dir = install_dir;
5848 }
5849
5850 myfree (resolved_install_folder);
5851 myfree (resolved_exec_path);
5852
5853 #else
5854
5855 char *install_dir = get_install_dir (exec_path);
5856 char *profile_dir = install_dir;
5857 char *session_dir = install_dir;
5858 char *shared_dir = install_dir;
5859
5860 #endif
5861
5862 data.install_dir = install_dir;
5863 data.profile_dir = profile_dir;
5864 data.session_dir = session_dir;
5865 data.shared_dir = shared_dir;
5866
5867 myfree (exec_path);
5868
5869 /**
5870 * kernel cache, we need to make sure folder exist
5871 */
5872
5873 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5874
5875 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5876
5877 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5878
5879 mkdir (kernels_folder, 0700);
5880
5881 myfree (kernels_folder);
5882
5883 /**
5884 * session
5885 */
5886
5887 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5888
5889 data.session = session;
5890
5891 char *eff_restore_file = (char *) mymalloc (session_size);
5892 char *new_restore_file = (char *) mymalloc (session_size);
5893
5894 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5895 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5896
5897 data.eff_restore_file = eff_restore_file;
5898 data.new_restore_file = new_restore_file;
5899
5900 if (((show == 1) || (left == 1)) && (restore == 1))
5901 {
5902 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5903 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5904
5905 return (-1);
5906 }
5907
5908 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5909 if ((show == 1) || (left == 1))
5910 {
5911 restore_disable = 1;
5912
5913 restore = 0;
5914 }
5915
5916 data.restore_disable = restore_disable;
5917
5918 restore_data_t *rd = init_restore (argc, argv);
5919
5920 data.rd = rd;
5921
5922 /**
5923 * restore file
5924 */
5925
5926 if (restore == 1)
5927 {
5928 read_restore (eff_restore_file, rd);
5929
5930 if (rd->version_bin < RESTORE_MIN)
5931 {
5932 log_error ("ERROR: Incompatible restore-file version");
5933
5934 return (-1);
5935 }
5936
5937 myargc = rd->argc;
5938 myargv = rd->argv;
5939
5940 #ifdef _POSIX
5941 rd->pid = getpid ();
5942 #elif _WIN
5943 rd->pid = GetCurrentProcessId ();
5944 #endif
5945 }
5946
5947 uint hash_mode_chgd = 0;
5948 uint runtime_chgd = 0;
5949 uint kernel_loops_chgd = 0;
5950 uint kernel_accel_chgd = 0;
5951 uint attack_mode_chgd = 0;
5952 uint outfile_format_chgd = 0;
5953 uint rp_gen_seed_chgd = 0;
5954 uint remove_timer_chgd = 0;
5955 uint increment_min_chgd = 0;
5956 uint increment_max_chgd = 0;
5957 uint workload_profile_chgd = 0;
5958 uint opencl_vector_width_chgd = 0;
5959
5960 optind = 1;
5961 optopt = 0;
5962 option_index = 0;
5963
5964 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5965 {
5966 switch (c)
5967 {
5968 //case IDX_HELP: usage = 1; break;
5969 //case IDX_VERSION: version = 1; break;
5970 //case IDX_RESTORE: restore = 1; break;
5971 case IDX_QUIET: quiet = 1; break;
5972 //case IDX_SHOW: show = 1; break;
5973 case IDX_SHOW: break;
5974 //case IDX_LEFT: left = 1; break;
5975 case IDX_LEFT: break;
5976 case IDX_USERNAME: username = 1; break;
5977 case IDX_REMOVE: remove = 1; break;
5978 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5979 remove_timer_chgd = 1; break;
5980 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5981 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5982 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5983 case IDX_DEBUG_FILE: debug_file = optarg; break;
5984 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5985 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5986 case IDX_FORCE: force = 1; break;
5987 case IDX_SKIP: skip = atoll (optarg); break;
5988 case IDX_LIMIT: limit = atoll (optarg); break;
5989 case IDX_KEYSPACE: keyspace = 1; break;
5990 case IDX_BENCHMARK: benchmark = 1; break;
5991 case IDX_RESTORE: break;
5992 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5993 case IDX_STATUS: status = 1; break;
5994 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5995 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5996 case IDX_LOOPBACK: loopback = 1; break;
5997 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5998 //case IDX_SESSION: session = optarg; break;
5999 case IDX_SESSION: break;
6000 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6001 hash_mode_chgd = 1; break;
6002 case IDX_RUNTIME: runtime = atoi (optarg);
6003 runtime_chgd = 1; break;
6004 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6005 attack_mode_chgd = 1; break;
6006 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6007 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6008 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6009 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6010 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6011 rp_gen_seed_chgd = 1; break;
6012 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6013 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6014 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6015 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6016 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6017 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6018 case IDX_OUTFILE: outfile = optarg; break;
6019 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6020 outfile_format_chgd = 1; break;
6021 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6022 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6023 case IDX_HEX_CHARSET: hex_charset = 1; break;
6024 case IDX_HEX_SALT: hex_salt = 1; break;
6025 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6026 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6027 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6028 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6029 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6030 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6031 opencl_vector_width_chgd = 1; break;
6032 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6033 workload_profile_chgd = 1; break;
6034 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6035 kernel_accel_chgd = 1; break;
6036 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6037 kernel_loops_chgd = 1; break;
6038 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6039 #ifdef HAVE_HWMON
6040 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6041 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6042 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6043 #endif // HAVE_HWMON
6044 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6045 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6046 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6047 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6048 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6049 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6050 case IDX_SEPARATOR: separator = optarg[0]; break;
6051 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6052 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6053 case IDX_INCREMENT: increment = 1; break;
6054 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6055 increment_min_chgd = 1; break;
6056 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6057 increment_max_chgd = 1; break;
6058 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6059 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6060 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6061 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6062
6063 default:
6064 log_error ("ERROR: Invalid argument specified");
6065 return (-1);
6066 }
6067 }
6068
6069 if (optopt != 0)
6070 {
6071 log_error ("ERROR: Invalid argument specified");
6072
6073 return (-1);
6074 }
6075
6076 /**
6077 * Inform user things getting started,
6078 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6079 * - we do not need to check algorithm_pos
6080 */
6081
6082 if (quiet == 0)
6083 {
6084 if (benchmark == 1)
6085 {
6086 if (machine_readable == 0)
6087 {
6088 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6089 log_info ("");
6090 }
6091 else
6092 {
6093 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6094 }
6095 }
6096 else if (restore == 1)
6097 {
6098 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6099 log_info ("");
6100 }
6101 else
6102 {
6103 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6104 log_info ("");
6105 }
6106 }
6107
6108 /**
6109 * sanity check
6110 */
6111
6112 if (attack_mode > 7)
6113 {
6114 log_error ("ERROR: Invalid attack-mode specified");
6115
6116 return (-1);
6117 }
6118
6119 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6120 {
6121 log_error ("ERROR: Invalid runtime specified");
6122
6123 return (-1);
6124 }
6125
6126 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6127 {
6128 log_error ("ERROR: Invalid hash-type specified");
6129
6130 return (-1);
6131 }
6132
6133 // renamed hash modes
6134
6135 if (hash_mode_chgd)
6136 {
6137 int n = -1;
6138
6139 switch (hash_mode)
6140 {
6141 case 123: n = 124;
6142 break;
6143 }
6144
6145 if (n >= 0)
6146 {
6147 log_error ("Old -m specified, use -m %d instead", n);
6148
6149 return (-1);
6150 }
6151 }
6152
6153 if (username == 1)
6154 {
6155 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6156 {
6157 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if (outfile_format > 16)
6164 {
6165 log_error ("ERROR: Invalid outfile-format specified");
6166
6167 return (-1);
6168 }
6169
6170 if (left == 1)
6171 {
6172 if (outfile_format_chgd == 1)
6173 {
6174 if (outfile_format > 1)
6175 {
6176 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6177
6178 return (-1);
6179 }
6180 }
6181 else
6182 {
6183 outfile_format = OUTFILE_FMT_HASH;
6184 }
6185 }
6186
6187 if (show == 1)
6188 {
6189 if (outfile_format_chgd == 1)
6190 {
6191 if ((outfile_format > 7) && (outfile_format < 16))
6192 {
6193 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6194
6195 return (-1);
6196 }
6197 }
6198 }
6199
6200 if (increment_min < INCREMENT_MIN)
6201 {
6202 log_error ("ERROR: Invalid increment-min specified");
6203
6204 return (-1);
6205 }
6206
6207 if (increment_max > INCREMENT_MAX)
6208 {
6209 log_error ("ERROR: Invalid increment-max specified");
6210
6211 return (-1);
6212 }
6213
6214 if (increment_min > increment_max)
6215 {
6216 log_error ("ERROR: Invalid increment-min specified");
6217
6218 return (-1);
6219 }
6220
6221 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6222 {
6223 log_error ("ERROR: increment is not allowed in attack-mode 0");
6224
6225 return (-1);
6226 }
6227
6228 if ((increment == 0) && (increment_min_chgd == 1))
6229 {
6230 log_error ("ERROR: increment-min is only supported together with increment switch");
6231
6232 return (-1);
6233 }
6234
6235 if ((increment == 0) && (increment_max_chgd == 1))
6236 {
6237 log_error ("ERROR: increment-max is only supported together with increment switch");
6238
6239 return (-1);
6240 }
6241
6242 if (rp_files_cnt && rp_gen)
6243 {
6244 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6245
6246 return (-1);
6247 }
6248
6249 if (rp_files_cnt || rp_gen)
6250 {
6251 if (attack_mode != ATTACK_MODE_STRAIGHT)
6252 {
6253 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (rp_gen_func_min > rp_gen_func_max)
6260 {
6261 log_error ("ERROR: Invalid rp-gen-func-min specified");
6262
6263 return (-1);
6264 }
6265
6266 if (kernel_accel_chgd == 1)
6267 {
6268 if (force == 0)
6269 {
6270 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6271 log_info ("Please consider using the option -w instead");
6272 log_info ("You can use --force to override this but do not post error reports if you do so");
6273 log_info ("");
6274
6275 return (-1);
6276 }
6277
6278 if (kernel_accel < 1)
6279 {
6280 log_error ("ERROR: Invalid kernel-accel specified");
6281
6282 return (-1);
6283 }
6284
6285 if (kernel_accel > 1024)
6286 {
6287 log_error ("ERROR: Invalid kernel-accel specified");
6288
6289 return (-1);
6290 }
6291 }
6292
6293 if (kernel_loops_chgd == 1)
6294 {
6295 if (force == 0)
6296 {
6297 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6298 log_info ("Please consider using the option -w instead");
6299 log_info ("You can use --force to override this but do not post error reports if you do so");
6300 log_info ("");
6301
6302 return (-1);
6303 }
6304
6305 if (kernel_loops < 1)
6306 {
6307 log_error ("ERROR: Invalid kernel-loops specified");
6308
6309 return (-1);
6310 }
6311
6312 if (kernel_loops > 1024)
6313 {
6314 log_error ("ERROR: Invalid kernel-loops specified");
6315
6316 return (-1);
6317 }
6318 }
6319
6320 if ((workload_profile < 1) || (workload_profile > 4))
6321 {
6322 log_error ("ERROR: workload-profile %i not available", workload_profile);
6323
6324 return (-1);
6325 }
6326
6327 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6328 {
6329 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6330
6331 return (-1);
6332 }
6333
6334 if (show == 1 || left == 1)
6335 {
6336 attack_mode = ATTACK_MODE_NONE;
6337
6338 if (remove == 1)
6339 {
6340 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6341
6342 return (-1);
6343 }
6344
6345 if (potfile_disable == 1)
6346 {
6347 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 uint attack_kern = ATTACK_KERN_NONE;
6354
6355 switch (attack_mode)
6356 {
6357 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6358 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6359 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6360 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6361 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6362 }
6363
6364 if (benchmark == 0)
6365 {
6366 if (keyspace == 1)
6367 {
6368 int num_additional_params = 1;
6369
6370 if (attack_kern == ATTACK_KERN_COMBI)
6371 {
6372 num_additional_params = 2;
6373 }
6374
6375 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6376
6377 if (keyspace_wordlist_specified == 0) optind--;
6378 }
6379
6380 if (attack_kern == ATTACK_KERN_NONE)
6381 {
6382 if ((optind + 1) != myargc)
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6390 {
6391 if ((optind + 1) > myargc)
6392 {
6393 usage_mini_print (myargv[0]);
6394
6395 return (-1);
6396 }
6397 }
6398 else if (attack_kern == ATTACK_KERN_COMBI)
6399 {
6400 if ((optind + 3) != myargc)
6401 {
6402 usage_mini_print (myargv[0]);
6403
6404 return (-1);
6405 }
6406 }
6407 else if (attack_kern == ATTACK_KERN_BF)
6408 {
6409 if ((optind + 1) > myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else
6417 {
6418 usage_mini_print (myargv[0]);
6419
6420 return (-1);
6421 }
6422 }
6423 else
6424 {
6425 if (myargv[optind] != 0)
6426 {
6427 log_error ("ERROR: Invalid argument for benchmark mode specified");
6428
6429 return (-1);
6430 }
6431
6432 if (attack_mode_chgd == 1)
6433 {
6434 if (attack_mode != ATTACK_MODE_BF)
6435 {
6436 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6437
6438 return (-1);
6439 }
6440 }
6441 }
6442
6443 if (skip != 0 && limit != 0)
6444 {
6445 limit += skip;
6446 }
6447
6448 if (keyspace == 1)
6449 {
6450 if (show == 1)
6451 {
6452 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6453
6454 return (-1);
6455 }
6456 else if (left == 1)
6457 {
6458 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6459
6460 return (-1);
6461 }
6462
6463 potfile_disable = 1;
6464
6465 restore_disable = 1;
6466
6467 restore = 0;
6468
6469 weak_hash_threshold = 0;
6470
6471 quiet = 1;
6472 }
6473
6474 if (remove_timer_chgd == 1)
6475 {
6476 if (remove == 0)
6477 {
6478 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6479
6480 return (-1);
6481 }
6482
6483 if (remove_timer < 1)
6484 {
6485 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6486
6487 return (-1);
6488 }
6489 }
6490
6491 if (loopback == 1)
6492 {
6493 if (attack_mode == ATTACK_MODE_STRAIGHT)
6494 {
6495 if ((rp_files_cnt == 0) && (rp_gen == 0))
6496 {
6497 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6498
6499 return (-1);
6500 }
6501 }
6502 else
6503 {
6504 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6505
6506 return (-1);
6507 }
6508 }
6509
6510 if (debug_mode > 0)
6511 {
6512 if (attack_mode != ATTACK_MODE_STRAIGHT)
6513 {
6514 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6515
6516 return (-1);
6517 }
6518
6519 if ((rp_files_cnt == 0) && (rp_gen == 0))
6520 {
6521 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6522
6523 return (-1);
6524 }
6525 }
6526
6527 if (debug_mode > 4)
6528 {
6529 log_error ("ERROR: Invalid debug-mode specified");
6530
6531 return (-1);
6532 }
6533
6534 if (debug_file != NULL)
6535 {
6536 if (debug_mode < 1)
6537 {
6538 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (induction_dir != NULL)
6545 {
6546 if (attack_mode == ATTACK_MODE_BF)
6547 {
6548 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (attack_mode != ATTACK_MODE_STRAIGHT)
6555 {
6556 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6557 {
6558 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6559
6560 return (-1);
6561 }
6562
6563 weak_hash_threshold = 0;
6564 }
6565
6566 /**
6567 * induction directory
6568 */
6569
6570 char *induction_directory = NULL;
6571
6572 if (attack_mode != ATTACK_MODE_BF)
6573 {
6574 if (induction_dir == NULL)
6575 {
6576 induction_directory = (char *) mymalloc (session_size);
6577
6578 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6579
6580 // create induction folder if it does not already exist
6581
6582 if (keyspace == 0)
6583 {
6584 if (rmdir (induction_directory) == -1)
6585 {
6586 if (errno == ENOENT)
6587 {
6588 // good, we can ignore
6589 }
6590 else if (errno == ENOTEMPTY)
6591 {
6592 char *induction_directory_mv = (char *) mymalloc (session_size);
6593
6594 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6595
6596 if (rename (induction_directory, induction_directory_mv) != 0)
6597 {
6598 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6599
6600 return (-1);
6601 }
6602 }
6603 else
6604 {
6605 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6606
6607 return (-1);
6608 }
6609 }
6610
6611 if (mkdir (induction_directory, 0700) == -1)
6612 {
6613 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6614
6615 return (-1);
6616 }
6617 }
6618 }
6619 else
6620 {
6621 induction_directory = induction_dir;
6622 }
6623 }
6624
6625 data.induction_directory = induction_directory;
6626
6627 /**
6628 * loopback
6629 */
6630
6631 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6632
6633 char *loopback_file = (char *) mymalloc (loopback_size);
6634
6635 /**
6636 * tuning db
6637 */
6638
6639 char tuning_db_file[256] = { 0 };
6640
6641 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6642
6643 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6644
6645 /**
6646 * outfile-check directory
6647 */
6648
6649 char *outfile_check_directory = NULL;
6650
6651 if (outfile_check_dir == NULL)
6652 {
6653 outfile_check_directory = (char *) mymalloc (session_size);
6654
6655 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6656 }
6657 else
6658 {
6659 outfile_check_directory = outfile_check_dir;
6660 }
6661
6662 data.outfile_check_directory = outfile_check_directory;
6663
6664 if (keyspace == 0)
6665 {
6666 struct stat outfile_check_stat;
6667
6668 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6669 {
6670 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6671
6672 if (is_dir == 0)
6673 {
6674 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6675
6676 return (-1);
6677 }
6678 }
6679 else if (outfile_check_dir == NULL)
6680 {
6681 if (mkdir (outfile_check_directory, 0700) == -1)
6682 {
6683 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6684
6685 return (-1);
6686 }
6687 }
6688 }
6689
6690 /**
6691 * special other stuff
6692 */
6693
6694 if (hash_mode == 9710)
6695 {
6696 outfile_format = 5;
6697 outfile_format_chgd = 1;
6698 }
6699
6700 if (hash_mode == 9810)
6701 {
6702 outfile_format = 5;
6703 outfile_format_chgd = 1;
6704 }
6705
6706 if (hash_mode == 10410)
6707 {
6708 outfile_format = 5;
6709 outfile_format_chgd = 1;
6710 }
6711
6712 /**
6713 * store stuff
6714 */
6715
6716 data.hash_mode = hash_mode;
6717 data.restore = restore;
6718 data.restore_timer = restore_timer;
6719 data.restore_disable = restore_disable;
6720 data.status = status;
6721 data.status_timer = status_timer;
6722 data.machine_readable = machine_readable;
6723 data.loopback = loopback;
6724 data.runtime = runtime;
6725 data.remove = remove;
6726 data.remove_timer = remove_timer;
6727 data.debug_mode = debug_mode;
6728 data.debug_file = debug_file;
6729 data.username = username;
6730 data.quiet = quiet;
6731 data.outfile = outfile;
6732 data.outfile_format = outfile_format;
6733 data.outfile_autohex = outfile_autohex;
6734 data.hex_charset = hex_charset;
6735 data.hex_salt = hex_salt;
6736 data.hex_wordlist = hex_wordlist;
6737 data.separator = separator;
6738 data.rp_files = rp_files;
6739 data.rp_files_cnt = rp_files_cnt;
6740 data.rp_gen = rp_gen;
6741 data.rp_gen_seed = rp_gen_seed;
6742 data.force = force;
6743 data.benchmark = benchmark;
6744 data.skip = skip;
6745 data.limit = limit;
6746 #ifdef HAVE_HWMON
6747 data.powertune_enable = powertune_enable;
6748 #endif
6749 data.logfile_disable = logfile_disable;
6750 data.truecrypt_keyfiles = truecrypt_keyfiles;
6751 data.veracrypt_keyfiles = veracrypt_keyfiles;
6752 data.veracrypt_pim = veracrypt_pim;
6753 data.scrypt_tmto = scrypt_tmto;
6754 data.workload_profile = workload_profile;
6755
6756 /**
6757 * cpu affinity
6758 */
6759
6760 if (cpu_affinity)
6761 {
6762 set_cpu_affinity (cpu_affinity);
6763 }
6764
6765 if (rp_gen_seed_chgd == 0)
6766 {
6767 srand (proc_start);
6768 }
6769 else
6770 {
6771 srand (rp_gen_seed);
6772 }
6773
6774 /**
6775 * logfile init
6776 */
6777
6778 if (logfile_disable == 0)
6779 {
6780 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6781
6782 char *logfile = (char *) mymalloc (logfile_size);
6783
6784 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6785
6786 data.logfile = logfile;
6787
6788 char *topid = logfile_generate_topid ();
6789
6790 data.topid = topid;
6791 }
6792
6793 // logfile_append() checks for logfile_disable internally to make it easier from here
6794
6795 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6796 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6797 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6798 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6799 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6800 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6801 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6802 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6803 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6804 #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));
6805
6806 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6807 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6808 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6809 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6810 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6811 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6812 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6813 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6814
6815 logfile_top_msg ("START");
6816
6817 logfile_top_uint (attack_mode);
6818 logfile_top_uint (attack_kern);
6819 logfile_top_uint (benchmark);
6820 logfile_top_uint (bitmap_min);
6821 logfile_top_uint (bitmap_max);
6822 logfile_top_uint (debug_mode);
6823 logfile_top_uint (force);
6824 logfile_top_uint (kernel_accel);
6825 logfile_top_uint (kernel_loops);
6826 logfile_top_uint (gpu_temp_disable);
6827 #ifdef HAVE_HWMON
6828 logfile_top_uint (gpu_temp_abort);
6829 logfile_top_uint (gpu_temp_retain);
6830 #endif
6831 logfile_top_uint (hash_mode);
6832 logfile_top_uint (hex_charset);
6833 logfile_top_uint (hex_salt);
6834 logfile_top_uint (hex_wordlist);
6835 logfile_top_uint (increment);
6836 logfile_top_uint (increment_max);
6837 logfile_top_uint (increment_min);
6838 logfile_top_uint (keyspace);
6839 logfile_top_uint (left);
6840 logfile_top_uint (logfile_disable);
6841 logfile_top_uint (loopback);
6842 logfile_top_uint (markov_classic);
6843 logfile_top_uint (markov_disable);
6844 logfile_top_uint (markov_threshold);
6845 logfile_top_uint (outfile_autohex);
6846 logfile_top_uint (outfile_check_timer);
6847 logfile_top_uint (outfile_format);
6848 logfile_top_uint (potfile_disable);
6849 logfile_top_string (potfile_path);
6850 #if defined(HAVE_HWMON)
6851 logfile_top_uint (powertune_enable);
6852 #endif
6853 logfile_top_uint (scrypt_tmto);
6854 logfile_top_uint (quiet);
6855 logfile_top_uint (remove);
6856 logfile_top_uint (remove_timer);
6857 logfile_top_uint (restore);
6858 logfile_top_uint (restore_disable);
6859 logfile_top_uint (restore_timer);
6860 logfile_top_uint (rp_gen);
6861 logfile_top_uint (rp_gen_func_max);
6862 logfile_top_uint (rp_gen_func_min);
6863 logfile_top_uint (rp_gen_seed);
6864 logfile_top_uint (runtime);
6865 logfile_top_uint (segment_size);
6866 logfile_top_uint (show);
6867 logfile_top_uint (status);
6868 logfile_top_uint (machine_readable);
6869 logfile_top_uint (status_timer);
6870 logfile_top_uint (usage);
6871 logfile_top_uint (username);
6872 logfile_top_uint (version);
6873 logfile_top_uint (weak_hash_threshold);
6874 logfile_top_uint (workload_profile);
6875 logfile_top_uint64 (limit);
6876 logfile_top_uint64 (skip);
6877 logfile_top_char (separator);
6878 logfile_top_string (cpu_affinity);
6879 logfile_top_string (custom_charset_1);
6880 logfile_top_string (custom_charset_2);
6881 logfile_top_string (custom_charset_3);
6882 logfile_top_string (custom_charset_4);
6883 logfile_top_string (debug_file);
6884 logfile_top_string (opencl_devices);
6885 logfile_top_string (opencl_platforms);
6886 logfile_top_string (opencl_device_types);
6887 logfile_top_uint (opencl_vector_width);
6888 logfile_top_string (induction_dir);
6889 logfile_top_string (markov_hcstat);
6890 logfile_top_string (outfile);
6891 logfile_top_string (outfile_check_dir);
6892 logfile_top_string (rule_buf_l);
6893 logfile_top_string (rule_buf_r);
6894 logfile_top_string (session);
6895 logfile_top_string (truecrypt_keyfiles);
6896 logfile_top_string (veracrypt_keyfiles);
6897 logfile_top_uint (veracrypt_pim);
6898
6899 /**
6900 * Init OpenCL library loader
6901 */
6902
6903 if (keyspace == 0)
6904 {
6905 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6906
6907 ocl_init (ocl);
6908
6909 data.ocl = ocl;
6910 }
6911
6912 /**
6913 * OpenCL platform selection
6914 */
6915
6916 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6917
6918 /**
6919 * OpenCL device selection
6920 */
6921
6922 u32 devices_filter = setup_devices_filter (opencl_devices);
6923
6924 /**
6925 * OpenCL device type selection
6926 */
6927
6928 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6929
6930 /**
6931 * benchmark
6932 */
6933
6934 if (benchmark == 1)
6935 {
6936 /**
6937 * disable useless stuff for benchmark
6938 */
6939
6940 status_timer = 0;
6941 restore_timer = 0;
6942 restore_disable = 1;
6943 potfile_disable = 1;
6944 weak_hash_threshold = 0;
6945 gpu_temp_disable = 1;
6946
6947 #ifdef HAVE_HWMON
6948 powertune_enable = 1;
6949 #endif
6950
6951 data.status_timer = status_timer;
6952 data.restore_timer = restore_timer;
6953 data.restore_disable = restore_disable;
6954
6955 /**
6956 * force attack mode to be bruteforce
6957 */
6958
6959 attack_mode = ATTACK_MODE_BF;
6960 attack_kern = ATTACK_KERN_BF;
6961
6962 if (workload_profile_chgd == 0)
6963 {
6964 workload_profile = 3;
6965
6966 data.workload_profile = workload_profile;
6967 }
6968 }
6969
6970 /**
6971 * config
6972 */
6973
6974 uint hash_type = 0;
6975 uint salt_type = 0;
6976 uint attack_exec = 0;
6977 uint opts_type = 0;
6978 uint kern_type = 0;
6979 uint dgst_size = 0;
6980 uint esalt_size = 0;
6981 uint opti_type = 0;
6982 uint dgst_pos0 = -1;
6983 uint dgst_pos1 = -1;
6984 uint dgst_pos2 = -1;
6985 uint dgst_pos3 = -1;
6986
6987 int (*parse_func) (char *, uint, hash_t *);
6988 int (*sort_by_digest) (const void *, const void *);
6989
6990 uint algorithm_pos = 0;
6991 uint algorithm_max = 1;
6992
6993 uint *algorithms = default_benchmark_algorithms;
6994
6995 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6996
6997 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6998 {
6999 /*
7000 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7001 * the following algos are skipped entirely
7002 */
7003
7004 if (algorithm_pos > 0)
7005 {
7006 local_free (rd);
7007
7008 rd = init_restore (argc, argv);
7009
7010 data.rd = rd;
7011 }
7012
7013 /**
7014 * update hash_mode in case of multihash benchmark
7015 */
7016
7017 if (benchmark == 1)
7018 {
7019 if (hash_mode_chgd == 0)
7020 {
7021 hash_mode = algorithms[algorithm_pos];
7022
7023 data.hash_mode = hash_mode;
7024 }
7025
7026 quiet = 1;
7027
7028 data.quiet = quiet;
7029 }
7030
7031 switch (hash_mode)
7032 {
7033 case 0: hash_type = HASH_TYPE_MD5;
7034 salt_type = SALT_TYPE_NONE;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_LE
7037 | OPTS_TYPE_PT_ADD80
7038 | OPTS_TYPE_PT_ADDBITS14;
7039 kern_type = KERN_TYPE_MD5;
7040 dgst_size = DGST_SIZE_4_4;
7041 parse_func = md5_parse_hash;
7042 sort_by_digest = sort_by_digest_4_4;
7043 opti_type = OPTI_TYPE_ZERO_BYTE
7044 | OPTI_TYPE_PRECOMPUTE_INIT
7045 | OPTI_TYPE_PRECOMPUTE_MERKLE
7046 | OPTI_TYPE_MEET_IN_MIDDLE
7047 | OPTI_TYPE_EARLY_SKIP
7048 | OPTI_TYPE_NOT_ITERATED
7049 | OPTI_TYPE_NOT_SALTED
7050 | OPTI_TYPE_RAW_HASH;
7051 dgst_pos0 = 0;
7052 dgst_pos1 = 3;
7053 dgst_pos2 = 2;
7054 dgst_pos3 = 1;
7055 break;
7056
7057 case 10: hash_type = HASH_TYPE_MD5;
7058 salt_type = SALT_TYPE_INTERN;
7059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7060 opts_type = OPTS_TYPE_PT_GENERATE_LE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS14;
7063 kern_type = KERN_TYPE_MD5_PWSLT;
7064 dgst_size = DGST_SIZE_4_4;
7065 parse_func = md5s_parse_hash;
7066 sort_by_digest = sort_by_digest_4_4;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_MEET_IN_MIDDLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 0;
7076 dgst_pos1 = 3;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 11: hash_type = HASH_TYPE_MD5;
7082 salt_type = SALT_TYPE_INTERN;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_LE
7085 | OPTS_TYPE_ST_ADD80
7086 | OPTS_TYPE_ST_ADDBITS14;
7087 kern_type = KERN_TYPE_MD5_PWSLT;
7088 dgst_size = DGST_SIZE_4_4;
7089 parse_func = joomla_parse_hash;
7090 sort_by_digest = sort_by_digest_4_4;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_MEET_IN_MIDDLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_APPENDED_SALT
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 0;
7100 dgst_pos1 = 3;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 12: hash_type = HASH_TYPE_MD5;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_LE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS14;
7111 kern_type = KERN_TYPE_MD5_PWSLT;
7112 dgst_size = DGST_SIZE_4_4;
7113 parse_func = postgresql_parse_hash;
7114 sort_by_digest = sort_by_digest_4_4;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_PRECOMPUTE_INIT
7117 | OPTI_TYPE_PRECOMPUTE_MERKLE
7118 | OPTI_TYPE_MEET_IN_MIDDLE
7119 | OPTI_TYPE_EARLY_SKIP
7120 | OPTI_TYPE_NOT_ITERATED
7121 | OPTI_TYPE_APPENDED_SALT
7122 | OPTI_TYPE_RAW_HASH;
7123 dgst_pos0 = 0;
7124 dgst_pos1 = 3;
7125 dgst_pos2 = 2;
7126 dgst_pos3 = 1;
7127 break;
7128
7129 case 20: hash_type = HASH_TYPE_MD5;
7130 salt_type = SALT_TYPE_INTERN;
7131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7132 opts_type = OPTS_TYPE_PT_GENERATE_LE
7133 | OPTS_TYPE_PT_ADD80
7134 | OPTS_TYPE_PT_ADDBITS14;
7135 kern_type = KERN_TYPE_MD5_SLTPW;
7136 dgst_size = DGST_SIZE_4_4;
7137 parse_func = md5s_parse_hash;
7138 sort_by_digest = sort_by_digest_4_4;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_PREPENDED_SALT
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 0;
7147 dgst_pos1 = 3;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 21: hash_type = HASH_TYPE_MD5;
7153 salt_type = SALT_TYPE_INTERN;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_LE
7156 | OPTS_TYPE_PT_ADD80
7157 | OPTS_TYPE_PT_ADDBITS14;
7158 kern_type = KERN_TYPE_MD5_SLTPW;
7159 dgst_size = DGST_SIZE_4_4;
7160 parse_func = osc_parse_hash;
7161 sort_by_digest = sort_by_digest_4_4;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_PREPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 0;
7170 dgst_pos1 = 3;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 22: hash_type = HASH_TYPE_MD5;
7176 salt_type = SALT_TYPE_EMBEDDED;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_LE
7179 | OPTS_TYPE_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS14;
7181 kern_type = KERN_TYPE_MD5_SLTPW;
7182 dgst_size = DGST_SIZE_4_4;
7183 parse_func = netscreen_parse_hash;
7184 sort_by_digest = sort_by_digest_4_4;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 0;
7193 dgst_pos1 = 3;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 23: hash_type = HASH_TYPE_MD5;
7199 salt_type = SALT_TYPE_EMBEDDED;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_LE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS14;
7204 kern_type = KERN_TYPE_MD5_SLTPW;
7205 dgst_size = DGST_SIZE_4_4;
7206 parse_func = skype_parse_hash;
7207 sort_by_digest = sort_by_digest_4_4;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_PREPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 3;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 30: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE
7225 | OPTS_TYPE_PT_UNICODE
7226 | OPTS_TYPE_ST_ADD80
7227 | OPTS_TYPE_ST_ADDBITS14;
7228 kern_type = KERN_TYPE_MD5_PWUSLT;
7229 dgst_size = DGST_SIZE_4_4;
7230 parse_func = md5s_parse_hash;
7231 sort_by_digest = sort_by_digest_4_4;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_MEET_IN_MIDDLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_APPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 0;
7241 dgst_pos1 = 3;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 40: hash_type = HASH_TYPE_MD5;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_LE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS14
7252 | OPTS_TYPE_PT_UNICODE;
7253 kern_type = KERN_TYPE_MD5_SLTPWU;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = md5s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_EARLY_SKIP
7261 | OPTI_TYPE_NOT_ITERATED
7262 | OPTI_TYPE_PREPENDED_SALT
7263 | OPTI_TYPE_RAW_HASH;
7264 dgst_pos0 = 0;
7265 dgst_pos1 = 3;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 1;
7268 break;
7269
7270 case 50: hash_type = HASH_TYPE_MD5;
7271 salt_type = SALT_TYPE_INTERN;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_LE
7274 | OPTS_TYPE_ST_ADD80
7275 | OPTS_TYPE_ST_ADDBITS14;
7276 kern_type = KERN_TYPE_HMACMD5_PW;
7277 dgst_size = DGST_SIZE_4_4;
7278 parse_func = hmacmd5_parse_hash;
7279 sort_by_digest = sort_by_digest_4_4;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_NOT_ITERATED;
7282 dgst_pos0 = 0;
7283 dgst_pos1 = 3;
7284 dgst_pos2 = 2;
7285 dgst_pos3 = 1;
7286 break;
7287
7288 case 60: hash_type = HASH_TYPE_MD5;
7289 salt_type = SALT_TYPE_INTERN;
7290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7291 opts_type = OPTS_TYPE_PT_GENERATE_LE
7292 | OPTS_TYPE_PT_ADD80
7293 | OPTS_TYPE_PT_ADDBITS14;
7294 kern_type = KERN_TYPE_HMACMD5_SLT;
7295 dgst_size = DGST_SIZE_4_4;
7296 parse_func = hmacmd5_parse_hash;
7297 sort_by_digest = sort_by_digest_4_4;
7298 opti_type = OPTI_TYPE_ZERO_BYTE
7299 | OPTI_TYPE_NOT_ITERATED;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 3;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 100: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_NONE;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = sha1_parse_hash;
7315 sort_by_digest = sort_by_digest_4_5;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_NOT_SALTED
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 3;
7324 dgst_pos1 = 4;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 101: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_NONE;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_PT_ADD80
7334 | OPTS_TYPE_PT_ADDBITS15;
7335 kern_type = KERN_TYPE_SHA1;
7336 dgst_size = DGST_SIZE_4_5;
7337 parse_func = sha1b64_parse_hash;
7338 sort_by_digest = sort_by_digest_4_5;
7339 opti_type = OPTI_TYPE_ZERO_BYTE
7340 | OPTI_TYPE_PRECOMPUTE_INIT
7341 | OPTI_TYPE_PRECOMPUTE_MERKLE
7342 | OPTI_TYPE_EARLY_SKIP
7343 | OPTI_TYPE_NOT_ITERATED
7344 | OPTI_TYPE_NOT_SALTED
7345 | OPTI_TYPE_RAW_HASH;
7346 dgst_pos0 = 3;
7347 dgst_pos1 = 4;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 110: hash_type = HASH_TYPE_SHA1;
7353 salt_type = SALT_TYPE_INTERN;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_BE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS15;
7358 kern_type = KERN_TYPE_SHA1_PWSLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = sha1s_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 111: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_EMBEDDED;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS15;
7381 kern_type = KERN_TYPE_SHA1_PWSLT;
7382 dgst_size = DGST_SIZE_4_5;
7383 parse_func = sha1b64s_parse_hash;
7384 sort_by_digest = sort_by_digest_4_5;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED
7390 | OPTI_TYPE_APPENDED_SALT
7391 | OPTI_TYPE_RAW_HASH;
7392 dgst_pos0 = 3;
7393 dgst_pos1 = 4;
7394 dgst_pos2 = 2;
7395 dgst_pos3 = 1;
7396 break;
7397
7398 case 112: hash_type = HASH_TYPE_SHA1;
7399 salt_type = SALT_TYPE_INTERN;
7400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_BE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = oracles_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 120: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_ADD80
7427 | OPTS_TYPE_PT_ADDBITS15;
7428 kern_type = KERN_TYPE_SHA1_SLTPW;
7429 dgst_size = DGST_SIZE_4_5;
7430 parse_func = sha1s_parse_hash;
7431 sort_by_digest = sort_by_digest_4_5;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_PRECOMPUTE_MERKLE
7435 | OPTI_TYPE_EARLY_SKIP
7436 | OPTI_TYPE_NOT_ITERATED
7437 | OPTI_TYPE_PREPENDED_SALT
7438 | OPTI_TYPE_RAW_HASH;
7439 dgst_pos0 = 3;
7440 dgst_pos1 = 4;
7441 dgst_pos2 = 2;
7442 dgst_pos3 = 1;
7443 break;
7444
7445 case 121: hash_type = HASH_TYPE_SHA1;
7446 salt_type = SALT_TYPE_INTERN;
7447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7448 opts_type = OPTS_TYPE_PT_GENERATE_BE
7449 | OPTS_TYPE_PT_ADD80
7450 | OPTS_TYPE_PT_ADDBITS15
7451 | OPTS_TYPE_ST_LOWER;
7452 kern_type = KERN_TYPE_SHA1_SLTPW;
7453 dgst_size = DGST_SIZE_4_5;
7454 parse_func = smf_parse_hash;
7455 sort_by_digest = sort_by_digest_4_5;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 3;
7464 dgst_pos1 = 4;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 122: hash_type = HASH_TYPE_SHA1;
7470 salt_type = SALT_TYPE_EMBEDDED;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_BE
7473 | OPTS_TYPE_PT_ADD80
7474 | OPTS_TYPE_PT_ADDBITS15
7475 | OPTS_TYPE_ST_HEX;
7476 kern_type = KERN_TYPE_SHA1_SLTPW;
7477 dgst_size = DGST_SIZE_4_5;
7478 parse_func = osx1_parse_hash;
7479 sort_by_digest = sort_by_digest_4_5;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_EARLY_SKIP
7484 | OPTI_TYPE_NOT_ITERATED
7485 | OPTI_TYPE_PREPENDED_SALT
7486 | OPTI_TYPE_RAW_HASH;
7487 dgst_pos0 = 3;
7488 dgst_pos1 = 4;
7489 dgst_pos2 = 2;
7490 dgst_pos3 = 1;
7491 break;
7492
7493 case 124: hash_type = HASH_TYPE_SHA1;
7494 salt_type = SALT_TYPE_EMBEDDED;
7495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_BE
7497 | OPTS_TYPE_PT_ADD80
7498 | OPTS_TYPE_PT_ADDBITS15;
7499 kern_type = KERN_TYPE_SHA1_SLTPW;
7500 dgst_size = DGST_SIZE_4_5;
7501 parse_func = djangosha1_parse_hash;
7502 sort_by_digest = sort_by_digest_4_5;
7503 opti_type = OPTI_TYPE_ZERO_BYTE
7504 | OPTI_TYPE_PRECOMPUTE_INIT
7505 | OPTI_TYPE_PRECOMPUTE_MERKLE
7506 | OPTI_TYPE_EARLY_SKIP
7507 | OPTI_TYPE_NOT_ITERATED
7508 | OPTI_TYPE_PREPENDED_SALT
7509 | OPTI_TYPE_RAW_HASH;
7510 dgst_pos0 = 3;
7511 dgst_pos1 = 4;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 1;
7514 break;
7515
7516 case 125: hash_type = HASH_TYPE_SHA1;
7517 salt_type = SALT_TYPE_EMBEDDED;
7518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_BE
7520 | OPTS_TYPE_PT_ADD80
7521 | OPTS_TYPE_PT_ADDBITS15
7522 | OPTS_TYPE_ST_HEX;
7523 kern_type = KERN_TYPE_SHA1_SLTPW;
7524 dgst_size = DGST_SIZE_4_5;
7525 parse_func = arubaos_parse_hash;
7526 sort_by_digest = sort_by_digest_4_5;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_PREPENDED_SALT
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 3;
7535 dgst_pos1 = 4;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 130: hash_type = HASH_TYPE_SHA1;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_BE
7544 | OPTS_TYPE_PT_UNICODE
7545 | OPTS_TYPE_ST_ADD80
7546 | OPTS_TYPE_ST_ADDBITS15;
7547 kern_type = KERN_TYPE_SHA1_PWUSLT;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = sha1s_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_EARLY_SKIP
7555 | OPTI_TYPE_NOT_ITERATED
7556 | OPTI_TYPE_APPENDED_SALT
7557 | OPTI_TYPE_RAW_HASH;
7558 dgst_pos0 = 3;
7559 dgst_pos1 = 4;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 1;
7562 break;
7563
7564 case 131: hash_type = HASH_TYPE_SHA1;
7565 salt_type = SALT_TYPE_EMBEDDED;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_BE
7568 | OPTS_TYPE_PT_UNICODE
7569 | OPTS_TYPE_PT_UPPER
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS15
7572 | OPTS_TYPE_ST_HEX;
7573 kern_type = KERN_TYPE_SHA1_PWUSLT;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = mssql2000_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_APPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 3;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 132: hash_type = HASH_TYPE_SHA1;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_BE
7594 | OPTS_TYPE_PT_UNICODE
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15
7597 | OPTS_TYPE_ST_HEX;
7598 kern_type = KERN_TYPE_SHA1_PWUSLT;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = mssql2005_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_APPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 133: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_EMBEDDED;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15;
7622 kern_type = KERN_TYPE_SHA1_PWUSLT;
7623 dgst_size = DGST_SIZE_4_5;
7624 parse_func = peoplesoft_parse_hash;
7625 sort_by_digest = sort_by_digest_4_5;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_EARLY_SKIP
7630 | OPTI_TYPE_NOT_ITERATED
7631 | OPTI_TYPE_APPENDED_SALT
7632 | OPTI_TYPE_RAW_HASH;
7633 dgst_pos0 = 3;
7634 dgst_pos1 = 4;
7635 dgst_pos2 = 2;
7636 dgst_pos3 = 1;
7637 break;
7638
7639 case 140: hash_type = HASH_TYPE_SHA1;
7640 salt_type = SALT_TYPE_INTERN;
7641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7642 opts_type = OPTS_TYPE_PT_GENERATE_BE
7643 | OPTS_TYPE_PT_ADD80
7644 | OPTS_TYPE_PT_ADDBITS15
7645 | OPTS_TYPE_PT_UNICODE;
7646 kern_type = KERN_TYPE_SHA1_SLTPWU;
7647 dgst_size = DGST_SIZE_4_5;
7648 parse_func = sha1s_parse_hash;
7649 sort_by_digest = sort_by_digest_4_5;
7650 opti_type = OPTI_TYPE_ZERO_BYTE
7651 | OPTI_TYPE_PRECOMPUTE_INIT
7652 | OPTI_TYPE_PRECOMPUTE_MERKLE
7653 | OPTI_TYPE_EARLY_SKIP
7654 | OPTI_TYPE_NOT_ITERATED
7655 | OPTI_TYPE_PREPENDED_SALT
7656 | OPTI_TYPE_RAW_HASH;
7657 dgst_pos0 = 3;
7658 dgst_pos1 = 4;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 1;
7661 break;
7662
7663 case 141: hash_type = HASH_TYPE_SHA1;
7664 salt_type = SALT_TYPE_EMBEDDED;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15
7669 | OPTS_TYPE_PT_UNICODE
7670 | OPTS_TYPE_ST_BASE64;
7671 kern_type = KERN_TYPE_SHA1_SLTPWU;
7672 dgst_size = DGST_SIZE_4_5;
7673 parse_func = episerver_parse_hash;
7674 sort_by_digest = sort_by_digest_4_5;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 4;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 150: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_INTERN;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_ST_ADD80
7693 | OPTS_TYPE_ST_ADDBITS15;
7694 kern_type = KERN_TYPE_HMACSHA1_PW;
7695 dgst_size = DGST_SIZE_4_5;
7696 parse_func = hmacsha1_parse_hash;
7697 sort_by_digest = sort_by_digest_4_5;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_NOT_ITERATED;
7700 dgst_pos0 = 3;
7701 dgst_pos1 = 4;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 1;
7704 break;
7705
7706 case 160: hash_type = HASH_TYPE_SHA1;
7707 salt_type = SALT_TYPE_INTERN;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_BE
7710 | OPTS_TYPE_PT_ADD80
7711 | OPTS_TYPE_PT_ADDBITS15;
7712 kern_type = KERN_TYPE_HMACSHA1_SLT;
7713 dgst_size = DGST_SIZE_4_5;
7714 parse_func = hmacsha1_parse_hash;
7715 sort_by_digest = sort_by_digest_4_5;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 4;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 190: hash_type = HASH_TYPE_SHA1;
7725 salt_type = SALT_TYPE_NONE;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7731 dgst_size = DGST_SIZE_4_5;
7732 parse_func = sha1linkedin_parse_hash;
7733 sort_by_digest = sort_by_digest_4_5;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_EARLY_SKIP
7737 | OPTI_TYPE_NOT_ITERATED
7738 | OPTI_TYPE_NOT_SALTED;
7739 dgst_pos0 = 0;
7740 dgst_pos1 = 4;
7741 dgst_pos2 = 3;
7742 dgst_pos3 = 2;
7743 break;
7744
7745 case 200: hash_type = HASH_TYPE_MYSQL;
7746 salt_type = SALT_TYPE_NONE;
7747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7748 opts_type = 0;
7749 kern_type = KERN_TYPE_MYSQL;
7750 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7751 parse_func = mysql323_parse_hash;
7752 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7753 opti_type = OPTI_TYPE_ZERO_BYTE;
7754 dgst_pos0 = 0;
7755 dgst_pos1 = 1;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 3;
7758 break;
7759
7760 case 300: hash_type = HASH_TYPE_SHA1;
7761 salt_type = SALT_TYPE_NONE;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_PT_ADD80
7765 | OPTS_TYPE_PT_ADDBITS15;
7766 kern_type = KERN_TYPE_MYSQL41;
7767 dgst_size = DGST_SIZE_4_5;
7768 parse_func = sha1_parse_hash;
7769 sort_by_digest = sort_by_digest_4_5;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_NOT_SALTED;
7776 dgst_pos0 = 3;
7777 dgst_pos1 = 4;
7778 dgst_pos2 = 2;
7779 dgst_pos3 = 1;
7780 break;
7781
7782 case 400: hash_type = HASH_TYPE_MD5;
7783 salt_type = SALT_TYPE_EMBEDDED;
7784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7786 kern_type = KERN_TYPE_PHPASS;
7787 dgst_size = DGST_SIZE_4_4;
7788 parse_func = phpass_parse_hash;
7789 sort_by_digest = sort_by_digest_4_4;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_SLOW_HASH_SIMD;
7792 dgst_pos0 = 0;
7793 dgst_pos1 = 1;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 3;
7796 break;
7797
7798 case 500: hash_type = HASH_TYPE_MD5;
7799 salt_type = SALT_TYPE_EMBEDDED;
7800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7802 kern_type = KERN_TYPE_MD5CRYPT;
7803 dgst_size = DGST_SIZE_4_4;
7804 parse_func = md5crypt_parse_hash;
7805 sort_by_digest = sort_by_digest_4_4;
7806 opti_type = OPTI_TYPE_ZERO_BYTE;
7807 dgst_pos0 = 0;
7808 dgst_pos1 = 1;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 3;
7811 break;
7812
7813 case 501: hash_type = HASH_TYPE_MD5;
7814 salt_type = SALT_TYPE_EMBEDDED;
7815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_LE
7817 | OPTS_TYPE_HASH_COPY;
7818 kern_type = KERN_TYPE_MD5CRYPT;
7819 dgst_size = DGST_SIZE_4_4;
7820 parse_func = juniper_parse_hash;
7821 sort_by_digest = sort_by_digest_4_4;
7822 opti_type = OPTI_TYPE_ZERO_BYTE;
7823 dgst_pos0 = 0;
7824 dgst_pos1 = 1;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 3;
7827 break;
7828
7829 case 900: hash_type = HASH_TYPE_MD4;
7830 salt_type = SALT_TYPE_NONE;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_LE
7833 | OPTS_TYPE_PT_ADD80
7834 | OPTS_TYPE_PT_ADDBITS14;
7835 kern_type = KERN_TYPE_MD4;
7836 dgst_size = DGST_SIZE_4_4;
7837 parse_func = md4_parse_hash;
7838 sort_by_digest = sort_by_digest_4_4;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_PRECOMPUTE_MERKLE
7842 | OPTI_TYPE_MEET_IN_MIDDLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_NOT_SALTED
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 1000: hash_type = HASH_TYPE_MD4;
7854 salt_type = SALT_TYPE_NONE;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE
7857 | OPTS_TYPE_PT_ADD80
7858 | OPTS_TYPE_PT_ADDBITS14
7859 | OPTS_TYPE_PT_UNICODE;
7860 kern_type = KERN_TYPE_MD4_PWU;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = md4_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_MEET_IN_MIDDLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 1100: hash_type = HASH_TYPE_MD4;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14
7884 | OPTS_TYPE_PT_UNICODE
7885 | OPTS_TYPE_ST_ADD80
7886 | OPTS_TYPE_ST_UNICODE
7887 | OPTS_TYPE_ST_LOWER;
7888 kern_type = KERN_TYPE_MD44_PWUSLT;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = dcc_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1400: hash_type = HASH_TYPE_SHA256;
7904 salt_type = SALT_TYPE_NONE;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_BE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS15;
7909 kern_type = KERN_TYPE_SHA256;
7910 dgst_size = DGST_SIZE_4_8;
7911 parse_func = sha256_parse_hash;
7912 sort_by_digest = sort_by_digest_4_8;
7913 opti_type = OPTI_TYPE_ZERO_BYTE
7914 | OPTI_TYPE_PRECOMPUTE_INIT
7915 | OPTI_TYPE_PRECOMPUTE_MERKLE
7916 | OPTI_TYPE_EARLY_SKIP
7917 | OPTI_TYPE_NOT_ITERATED
7918 | OPTI_TYPE_NOT_SALTED
7919 | OPTI_TYPE_RAW_HASH;
7920 dgst_pos0 = 3;
7921 dgst_pos1 = 7;
7922 dgst_pos2 = 2;
7923 dgst_pos3 = 6;
7924 break;
7925
7926 case 1410: hash_type = HASH_TYPE_SHA256;
7927 salt_type = SALT_TYPE_INTERN;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_BE
7930 | OPTS_TYPE_ST_ADD80
7931 | OPTS_TYPE_ST_ADDBITS15;
7932 kern_type = KERN_TYPE_SHA256_PWSLT;
7933 dgst_size = DGST_SIZE_4_8;
7934 parse_func = sha256s_parse_hash;
7935 sort_by_digest = sort_by_digest_4_8;
7936 opti_type = OPTI_TYPE_ZERO_BYTE
7937 | OPTI_TYPE_PRECOMPUTE_INIT
7938 | OPTI_TYPE_PRECOMPUTE_MERKLE
7939 | OPTI_TYPE_EARLY_SKIP
7940 | OPTI_TYPE_NOT_ITERATED
7941 | OPTI_TYPE_APPENDED_SALT
7942 | OPTI_TYPE_RAW_HASH;
7943 dgst_pos0 = 3;
7944 dgst_pos1 = 7;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 6;
7947 break;
7948
7949 case 1420: hash_type = HASH_TYPE_SHA256;
7950 salt_type = SALT_TYPE_INTERN;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_ADD80
7954 | OPTS_TYPE_PT_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA256_SLTPW;
7956 dgst_size = DGST_SIZE_4_8;
7957 parse_func = sha256s_parse_hash;
7958 sort_by_digest = sort_by_digest_4_8;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_PREPENDED_SALT
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 3;
7967 dgst_pos1 = 7;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 6;
7970 break;
7971
7972 case 1421: hash_type = HASH_TYPE_SHA256;
7973 salt_type = SALT_TYPE_EMBEDDED;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_ADD80
7977 | OPTS_TYPE_PT_ADDBITS15;
7978 kern_type = KERN_TYPE_SHA256_SLTPW;
7979 dgst_size = DGST_SIZE_4_8;
7980 parse_func = hmailserver_parse_hash;
7981 sort_by_digest = sort_by_digest_4_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_PREPENDED_SALT
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 7;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 6;
7993 break;
7994
7995 case 1430: hash_type = HASH_TYPE_SHA256;
7996 salt_type = SALT_TYPE_INTERN;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_UNICODE
8000 | OPTS_TYPE_ST_ADD80
8001 | OPTS_TYPE_ST_ADDBITS15;
8002 kern_type = KERN_TYPE_SHA256_PWUSLT;
8003 dgst_size = DGST_SIZE_4_8;
8004 parse_func = sha256s_parse_hash;
8005 sort_by_digest = sort_by_digest_4_8;
8006 opti_type = OPTI_TYPE_ZERO_BYTE
8007 | OPTI_TYPE_PRECOMPUTE_INIT
8008 | OPTI_TYPE_PRECOMPUTE_MERKLE
8009 | OPTI_TYPE_EARLY_SKIP
8010 | OPTI_TYPE_NOT_ITERATED
8011 | OPTI_TYPE_APPENDED_SALT
8012 | OPTI_TYPE_RAW_HASH;
8013 dgst_pos0 = 3;
8014 dgst_pos1 = 7;
8015 dgst_pos2 = 2;
8016 dgst_pos3 = 6;
8017 break;
8018
8019 case 1440: hash_type = HASH_TYPE_SHA256;
8020 salt_type = SALT_TYPE_INTERN;
8021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8022 opts_type = OPTS_TYPE_PT_GENERATE_BE
8023 | OPTS_TYPE_PT_ADD80
8024 | OPTS_TYPE_PT_ADDBITS15
8025 | OPTS_TYPE_PT_UNICODE;
8026 kern_type = KERN_TYPE_SHA256_SLTPWU;
8027 dgst_size = DGST_SIZE_4_8;
8028 parse_func = sha256s_parse_hash;
8029 sort_by_digest = sort_by_digest_4_8;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP
8034 | OPTI_TYPE_NOT_ITERATED
8035 | OPTI_TYPE_PREPENDED_SALT
8036 | OPTI_TYPE_RAW_HASH;
8037 dgst_pos0 = 3;
8038 dgst_pos1 = 7;
8039 dgst_pos2 = 2;
8040 dgst_pos3 = 6;
8041 break;
8042
8043 case 1441: hash_type = HASH_TYPE_SHA256;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_BE
8047 | OPTS_TYPE_PT_ADD80
8048 | OPTS_TYPE_PT_ADDBITS15
8049 | OPTS_TYPE_PT_UNICODE
8050 | OPTS_TYPE_ST_BASE64;
8051 kern_type = KERN_TYPE_SHA256_SLTPWU;
8052 dgst_size = DGST_SIZE_4_8;
8053 parse_func = episerver4_parse_hash;
8054 sort_by_digest = sort_by_digest_4_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 7;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 6;
8066 break;
8067
8068 case 1450: hash_type = HASH_TYPE_SHA256;
8069 salt_type = SALT_TYPE_INTERN;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_ST_ADD80;
8073 kern_type = KERN_TYPE_HMACSHA256_PW;
8074 dgst_size = DGST_SIZE_4_8;
8075 parse_func = hmacsha256_parse_hash;
8076 sort_by_digest = sort_by_digest_4_8;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_NOT_ITERATED;
8079 dgst_pos0 = 3;
8080 dgst_pos1 = 7;
8081 dgst_pos2 = 2;
8082 dgst_pos3 = 6;
8083 break;
8084
8085 case 1460: hash_type = HASH_TYPE_SHA256;
8086 salt_type = SALT_TYPE_INTERN;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS15;
8091 kern_type = KERN_TYPE_HMACSHA256_SLT;
8092 dgst_size = DGST_SIZE_4_8;
8093 parse_func = hmacsha256_parse_hash;
8094 sort_by_digest = sort_by_digest_4_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_NOT_ITERATED;
8097 dgst_pos0 = 3;
8098 dgst_pos1 = 7;
8099 dgst_pos2 = 2;
8100 dgst_pos3 = 6;
8101 break;
8102
8103 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8104 salt_type = SALT_TYPE_EMBEDDED;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_LE
8107 | OPTS_TYPE_PT_BITSLICE;
8108 kern_type = KERN_TYPE_DESCRYPT;
8109 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8110 parse_func = descrypt_parse_hash;
8111 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 1;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 3;
8118 break;
8119
8120 case 1600: hash_type = HASH_TYPE_MD5;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8124 kern_type = KERN_TYPE_APR1CRYPT;
8125 dgst_size = DGST_SIZE_4_4;
8126 parse_func = md5apr1_parse_hash;
8127 sort_by_digest = sort_by_digest_4_4;
8128 opti_type = OPTI_TYPE_ZERO_BYTE;
8129 dgst_pos0 = 0;
8130 dgst_pos1 = 1;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 3;
8133 break;
8134
8135 case 1700: hash_type = HASH_TYPE_SHA512;
8136 salt_type = SALT_TYPE_NONE;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_PT_ADD80
8140 | OPTS_TYPE_PT_ADDBITS15;
8141 kern_type = KERN_TYPE_SHA512;
8142 dgst_size = DGST_SIZE_8_8;
8143 parse_func = sha512_parse_hash;
8144 sort_by_digest = sort_by_digest_8_8;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_ITERATED
8150 | OPTI_TYPE_NOT_SALTED
8151 | OPTI_TYPE_USES_BITS_64
8152 | OPTI_TYPE_RAW_HASH;
8153 dgst_pos0 = 14;
8154 dgst_pos1 = 15;
8155 dgst_pos2 = 6;
8156 dgst_pos3 = 7;
8157 break;
8158
8159 case 1710: hash_type = HASH_TYPE_SHA512;
8160 salt_type = SALT_TYPE_INTERN;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_BE
8163 | OPTS_TYPE_ST_ADD80
8164 | OPTS_TYPE_ST_ADDBITS15;
8165 kern_type = KERN_TYPE_SHA512_PWSLT;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512s_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_INIT
8171 | OPTI_TYPE_PRECOMPUTE_MERKLE
8172 | OPTI_TYPE_EARLY_SKIP
8173 | OPTI_TYPE_NOT_ITERATED
8174 | OPTI_TYPE_APPENDED_SALT
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1711: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_ST_ADD80
8188 | OPTS_TYPE_ST_ADDBITS15;
8189 kern_type = KERN_TYPE_SHA512_PWSLT;
8190 dgst_size = DGST_SIZE_8_8;
8191 parse_func = sha512b64s_parse_hash;
8192 sort_by_digest = sort_by_digest_8_8;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_ITERATED
8198 | OPTI_TYPE_APPENDED_SALT
8199 | OPTI_TYPE_USES_BITS_64
8200 | OPTI_TYPE_RAW_HASH;
8201 dgst_pos0 = 14;
8202 dgst_pos1 = 15;
8203 dgst_pos2 = 6;
8204 dgst_pos3 = 7;
8205 break;
8206
8207 case 1720: hash_type = HASH_TYPE_SHA512;
8208 salt_type = SALT_TYPE_INTERN;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_BE
8211 | OPTS_TYPE_PT_ADD80
8212 | OPTS_TYPE_PT_ADDBITS15;
8213 kern_type = KERN_TYPE_SHA512_SLTPW;
8214 dgst_size = DGST_SIZE_8_8;
8215 parse_func = sha512s_parse_hash;
8216 sort_by_digest = sort_by_digest_8_8;
8217 opti_type = OPTI_TYPE_ZERO_BYTE
8218 | OPTI_TYPE_PRECOMPUTE_INIT
8219 | OPTI_TYPE_PRECOMPUTE_MERKLE
8220 | OPTI_TYPE_EARLY_SKIP
8221 | OPTI_TYPE_NOT_ITERATED
8222 | OPTI_TYPE_PREPENDED_SALT
8223 | OPTI_TYPE_USES_BITS_64
8224 | OPTI_TYPE_RAW_HASH;
8225 dgst_pos0 = 14;
8226 dgst_pos1 = 15;
8227 dgst_pos2 = 6;
8228 dgst_pos3 = 7;
8229 break;
8230
8231 case 1722: hash_type = HASH_TYPE_SHA512;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_BE
8235 | OPTS_TYPE_PT_ADD80
8236 | OPTS_TYPE_PT_ADDBITS15
8237 | OPTS_TYPE_ST_HEX;
8238 kern_type = KERN_TYPE_SHA512_SLTPW;
8239 dgst_size = DGST_SIZE_8_8;
8240 parse_func = osx512_parse_hash;
8241 sort_by_digest = sort_by_digest_8_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED
8247 | OPTI_TYPE_PREPENDED_SALT
8248 | OPTI_TYPE_USES_BITS_64
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 14;
8251 dgst_pos1 = 15;
8252 dgst_pos2 = 6;
8253 dgst_pos3 = 7;
8254 break;
8255
8256 case 1730: hash_type = HASH_TYPE_SHA512;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_UNICODE
8261 | OPTS_TYPE_ST_ADD80
8262 | OPTS_TYPE_ST_ADDBITS15;
8263 kern_type = KERN_TYPE_SHA512_PWSLTU;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = sha512s_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_APPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1731: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_UNICODE
8286 | OPTS_TYPE_ST_ADD80
8287 | OPTS_TYPE_ST_ADDBITS15
8288 | OPTS_TYPE_ST_HEX;
8289 kern_type = KERN_TYPE_SHA512_PWSLTU;
8290 dgst_size = DGST_SIZE_8_8;
8291 parse_func = mssql2012_parse_hash;
8292 sort_by_digest = sort_by_digest_8_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP
8297 | OPTI_TYPE_NOT_ITERATED
8298 | OPTI_TYPE_APPENDED_SALT
8299 | OPTI_TYPE_USES_BITS_64
8300 | OPTI_TYPE_RAW_HASH;
8301 dgst_pos0 = 14;
8302 dgst_pos1 = 15;
8303 dgst_pos2 = 6;
8304 dgst_pos3 = 7;
8305 break;
8306
8307 case 1740: hash_type = HASH_TYPE_SHA512;
8308 salt_type = SALT_TYPE_INTERN;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_BE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS15
8313 | OPTS_TYPE_PT_UNICODE;
8314 kern_type = KERN_TYPE_SHA512_SLTPWU;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = sha512s_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_PREPENDED_SALT
8324 | OPTI_TYPE_USES_BITS_64
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 14;
8327 dgst_pos1 = 15;
8328 dgst_pos2 = 6;
8329 dgst_pos3 = 7;
8330 break;
8331
8332 case 1750: hash_type = HASH_TYPE_SHA512;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_ST_ADD80;
8337 kern_type = KERN_TYPE_HMACSHA512_PW;
8338 dgst_size = DGST_SIZE_8_8;
8339 parse_func = hmacsha512_parse_hash;
8340 sort_by_digest = sort_by_digest_8_8;
8341 opti_type = OPTI_TYPE_ZERO_BYTE
8342 | OPTI_TYPE_USES_BITS_64
8343 | OPTI_TYPE_NOT_ITERATED;
8344 dgst_pos0 = 14;
8345 dgst_pos1 = 15;
8346 dgst_pos2 = 6;
8347 dgst_pos3 = 7;
8348 break;
8349
8350 case 1760: hash_type = HASH_TYPE_SHA512;
8351 salt_type = SALT_TYPE_INTERN;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_BE
8354 | OPTS_TYPE_PT_ADD80
8355 | OPTS_TYPE_PT_ADDBITS15;
8356 kern_type = KERN_TYPE_HMACSHA512_SLT;
8357 dgst_size = DGST_SIZE_8_8;
8358 parse_func = hmacsha512_parse_hash;
8359 sort_by_digest = sort_by_digest_8_8;
8360 opti_type = OPTI_TYPE_ZERO_BYTE
8361 | OPTI_TYPE_USES_BITS_64
8362 | OPTI_TYPE_NOT_ITERATED;
8363 dgst_pos0 = 14;
8364 dgst_pos1 = 15;
8365 dgst_pos2 = 6;
8366 dgst_pos3 = 7;
8367 break;
8368
8369 case 1800: hash_type = HASH_TYPE_SHA512;
8370 salt_type = SALT_TYPE_EMBEDDED;
8371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8373 kern_type = KERN_TYPE_SHA512CRYPT;
8374 dgst_size = DGST_SIZE_8_8;
8375 parse_func = sha512crypt_parse_hash;
8376 sort_by_digest = sort_by_digest_8_8;
8377 opti_type = OPTI_TYPE_ZERO_BYTE
8378 | OPTI_TYPE_USES_BITS_64;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 2100: hash_type = HASH_TYPE_DCC2;
8386 salt_type = SALT_TYPE_EMBEDDED;
8387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8389 | OPTS_TYPE_ST_LOWER
8390 | OPTS_TYPE_ST_UNICODE;
8391 kern_type = KERN_TYPE_DCC2;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = dcc2_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_SLOW_HASH_SIMD;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 2400: hash_type = HASH_TYPE_MD5;
8404 salt_type = SALT_TYPE_NONE;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8407 kern_type = KERN_TYPE_MD5PIX;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5pix_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP
8415 | OPTI_TYPE_NOT_ITERATED
8416 | OPTI_TYPE_NOT_SALTED;
8417 dgst_pos0 = 0;
8418 dgst_pos1 = 3;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 1;
8421 break;
8422
8423 case 2410: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_INTERN;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8427 kern_type = KERN_TYPE_MD5ASA;
8428 dgst_size = DGST_SIZE_4_4;
8429 parse_func = md5asa_parse_hash;
8430 sort_by_digest = sort_by_digest_4_4;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_ITERATED;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 2500: hash_type = HASH_TYPE_WPA;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8446 kern_type = KERN_TYPE_WPA;
8447 dgst_size = DGST_SIZE_4_4;
8448 parse_func = wpa_parse_hash;
8449 sort_by_digest = sort_by_digest_4_4;
8450 opti_type = OPTI_TYPE_ZERO_BYTE
8451 | OPTI_TYPE_SLOW_HASH_SIMD;
8452 dgst_pos0 = 0;
8453 dgst_pos1 = 1;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 3;
8456 break;
8457
8458 case 2600: hash_type = HASH_TYPE_MD5;
8459 salt_type = SALT_TYPE_VIRTUAL;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_LE
8462 | OPTS_TYPE_PT_ADD80
8463 | OPTS_TYPE_PT_ADDBITS14
8464 | OPTS_TYPE_ST_ADD80;
8465 kern_type = KERN_TYPE_MD55_PWSLT1;
8466 dgst_size = DGST_SIZE_4_4;
8467 parse_func = md5md5_parse_hash;
8468 sort_by_digest = sort_by_digest_4_4;
8469 opti_type = OPTI_TYPE_ZERO_BYTE
8470 | OPTI_TYPE_PRECOMPUTE_INIT
8471 | OPTI_TYPE_PRECOMPUTE_MERKLE
8472 | OPTI_TYPE_EARLY_SKIP;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 3;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 1;
8477 break;
8478
8479 case 2611: hash_type = HASH_TYPE_MD5;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS14
8485 | OPTS_TYPE_ST_ADD80;
8486 kern_type = KERN_TYPE_MD55_PWSLT1;
8487 dgst_size = DGST_SIZE_4_4;
8488 parse_func = vb3_parse_hash;
8489 sort_by_digest = sort_by_digest_4_4;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 3;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 1;
8498 break;
8499
8500 case 2612: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE
8504 | OPTS_TYPE_PT_ADD80
8505 | OPTS_TYPE_PT_ADDBITS14
8506 | OPTS_TYPE_ST_ADD80
8507 | OPTS_TYPE_ST_HEX;
8508 kern_type = KERN_TYPE_MD55_PWSLT1;
8509 dgst_size = DGST_SIZE_4_4;
8510 parse_func = phps_parse_hash;
8511 sort_by_digest = sort_by_digest_4_4;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_PRECOMPUTE_INIT
8514 | OPTI_TYPE_PRECOMPUTE_MERKLE
8515 | OPTI_TYPE_EARLY_SKIP;
8516 dgst_pos0 = 0;
8517 dgst_pos1 = 3;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 2711: hash_type = HASH_TYPE_MD5;
8523 salt_type = SALT_TYPE_INTERN;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_LE
8526 | OPTS_TYPE_PT_ADD80
8527 | OPTS_TYPE_PT_ADDBITS14
8528 | OPTS_TYPE_ST_ADD80;
8529 kern_type = KERN_TYPE_MD55_PWSLT2;
8530 dgst_size = DGST_SIZE_4_4;
8531 parse_func = vb30_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_EARLY_SKIP;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 3;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 1;
8540 break;
8541
8542 case 2811: hash_type = HASH_TYPE_MD5;
8543 salt_type = SALT_TYPE_INTERN;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE
8546 | OPTS_TYPE_PT_ADD80
8547 | OPTS_TYPE_PT_ADDBITS14;
8548 kern_type = KERN_TYPE_MD55_SLTPW;
8549 dgst_size = DGST_SIZE_4_4;
8550 parse_func = ipb2_parse_hash;
8551 sort_by_digest = sort_by_digest_4_4;
8552 opti_type = OPTI_TYPE_ZERO_BYTE
8553 | OPTI_TYPE_PRECOMPUTE_INIT
8554 | OPTI_TYPE_EARLY_SKIP;
8555 dgst_pos0 = 0;
8556 dgst_pos1 = 3;
8557 dgst_pos2 = 2;
8558 dgst_pos3 = 1;
8559 break;
8560
8561 case 3000: hash_type = HASH_TYPE_LM;
8562 salt_type = SALT_TYPE_NONE;
8563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_LE
8565 | OPTS_TYPE_PT_UPPER
8566 | OPTS_TYPE_PT_BITSLICE;
8567 kern_type = KERN_TYPE_LM;
8568 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8569 parse_func = lm_parse_hash;
8570 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8571 opti_type = OPTI_TYPE_ZERO_BYTE
8572 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 1;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 3;
8577 break;
8578
8579 case 3100: hash_type = HASH_TYPE_ORACLEH;
8580 salt_type = SALT_TYPE_INTERN;
8581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_LE
8583 | OPTS_TYPE_PT_UPPER
8584 | OPTS_TYPE_ST_UPPER;
8585 kern_type = KERN_TYPE_ORACLEH;
8586 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8587 parse_func = oracleh_parse_hash;
8588 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8589 opti_type = OPTI_TYPE_ZERO_BYTE;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 1;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 3;
8594 break;
8595
8596 case 3200: hash_type = HASH_TYPE_BCRYPT;
8597 salt_type = SALT_TYPE_EMBEDDED;
8598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE
8600 | OPTS_TYPE_ST_GENERATE_LE;
8601 kern_type = KERN_TYPE_BCRYPT;
8602 dgst_size = DGST_SIZE_4_6;
8603 parse_func = bcrypt_parse_hash;
8604 sort_by_digest = sort_by_digest_4_6;
8605 opti_type = OPTI_TYPE_ZERO_BYTE;
8606 dgst_pos0 = 0;
8607 dgst_pos1 = 1;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 3;
8610 break;
8611
8612 case 3710: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_INTERN;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS14;
8618 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8619 dgst_size = DGST_SIZE_4_4;
8620 parse_func = md5s_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4;
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_PRECOMPUTE_INIT
8624 | OPTI_TYPE_PRECOMPUTE_MERKLE
8625 | OPTI_TYPE_EARLY_SKIP;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 3;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 1;
8630 break;
8631
8632 case 3711: hash_type = HASH_TYPE_MD5;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_PT_ADD80
8637 | OPTS_TYPE_PT_ADDBITS14;
8638 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8639 dgst_size = DGST_SIZE_4_4;
8640 parse_func = mediawiki_b_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_EARLY_SKIP;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 3800: hash_type = HASH_TYPE_MD5;
8653 salt_type = SALT_TYPE_INTERN;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_ST_ADDBITS14;
8657 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8658 dgst_size = DGST_SIZE_4_4;
8659 parse_func = md5s_parse_hash;
8660 sort_by_digest = sort_by_digest_4_4;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_PRECOMPUTE_INIT
8663 | OPTI_TYPE_PRECOMPUTE_MERKLE
8664 | OPTI_TYPE_EARLY_SKIP
8665 | OPTI_TYPE_NOT_ITERATED
8666 | OPTI_TYPE_RAW_HASH;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 3;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 1;
8671 break;
8672
8673 case 4300: hash_type = HASH_TYPE_MD5;
8674 salt_type = SALT_TYPE_VIRTUAL;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE
8677 | OPTS_TYPE_PT_ADD80
8678 | OPTS_TYPE_PT_ADDBITS14
8679 | OPTS_TYPE_ST_ADD80;
8680 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8681 dgst_size = DGST_SIZE_4_4;
8682 parse_func = md5md5_parse_hash;
8683 sort_by_digest = sort_by_digest_4_4;
8684 opti_type = OPTI_TYPE_ZERO_BYTE
8685 | OPTI_TYPE_PRECOMPUTE_INIT
8686 | OPTI_TYPE_PRECOMPUTE_MERKLE
8687 | OPTI_TYPE_EARLY_SKIP;
8688 dgst_pos0 = 0;
8689 dgst_pos1 = 3;
8690 dgst_pos2 = 2;
8691 dgst_pos3 = 1;
8692 break;
8693
8694
8695 case 4400: hash_type = HASH_TYPE_MD5;
8696 salt_type = SALT_TYPE_NONE;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_BE
8699 | OPTS_TYPE_PT_ADD80
8700 | OPTS_TYPE_PT_ADDBITS15;
8701 kern_type = KERN_TYPE_MD5_SHA1;
8702 dgst_size = DGST_SIZE_4_4;
8703 parse_func = md5_parse_hash;
8704 sort_by_digest = sort_by_digest_4_4;
8705 opti_type = OPTI_TYPE_ZERO_BYTE
8706 | OPTI_TYPE_PRECOMPUTE_INIT
8707 | OPTI_TYPE_PRECOMPUTE_MERKLE
8708 | OPTI_TYPE_EARLY_SKIP
8709 | OPTI_TYPE_NOT_ITERATED
8710 | OPTI_TYPE_NOT_SALTED
8711 | OPTI_TYPE_RAW_HASH;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 3;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 1;
8716 break;
8717
8718 case 4500: hash_type = HASH_TYPE_SHA1;
8719 salt_type = SALT_TYPE_NONE;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_BE
8722 | OPTS_TYPE_PT_ADD80
8723 | OPTS_TYPE_PT_ADDBITS15;
8724 kern_type = KERN_TYPE_SHA11;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = sha1_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_PRECOMPUTE_INIT
8730 | OPTI_TYPE_PRECOMPUTE_MERKLE
8731 | OPTI_TYPE_EARLY_SKIP
8732 | OPTI_TYPE_NOT_SALTED;
8733 dgst_pos0 = 3;
8734 dgst_pos1 = 4;
8735 dgst_pos2 = 2;
8736 dgst_pos3 = 1;
8737 break;
8738
8739 case 4700: hash_type = HASH_TYPE_SHA1;
8740 salt_type = SALT_TYPE_NONE;
8741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8742 opts_type = OPTS_TYPE_PT_GENERATE_LE
8743 | OPTS_TYPE_PT_ADD80
8744 | OPTS_TYPE_PT_ADDBITS14;
8745 kern_type = KERN_TYPE_SHA1_MD5;
8746 dgst_size = DGST_SIZE_4_5;
8747 parse_func = sha1_parse_hash;
8748 sort_by_digest = sort_by_digest_4_5;
8749 opti_type = OPTI_TYPE_ZERO_BYTE
8750 | OPTI_TYPE_PRECOMPUTE_INIT
8751 | OPTI_TYPE_PRECOMPUTE_MERKLE
8752 | OPTI_TYPE_EARLY_SKIP
8753 | OPTI_TYPE_NOT_ITERATED
8754 | OPTI_TYPE_NOT_SALTED
8755 | OPTI_TYPE_RAW_HASH;
8756 dgst_pos0 = 3;
8757 dgst_pos1 = 4;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 1;
8760 break;
8761
8762 case 4800: hash_type = HASH_TYPE_MD5;
8763 salt_type = SALT_TYPE_EMBEDDED;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE
8766 | OPTS_TYPE_PT_ADDBITS14;
8767 kern_type = KERN_TYPE_MD5_CHAP;
8768 dgst_size = DGST_SIZE_4_4;
8769 parse_func = chap_parse_hash;
8770 sort_by_digest = sort_by_digest_4_4;
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_PRECOMPUTE_INIT
8773 | OPTI_TYPE_PRECOMPUTE_MERKLE
8774 | OPTI_TYPE_MEET_IN_MIDDLE
8775 | OPTI_TYPE_EARLY_SKIP
8776 | OPTI_TYPE_NOT_ITERATED
8777 | OPTI_TYPE_RAW_HASH;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 3;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 1;
8782 break;
8783
8784 case 4900: hash_type = HASH_TYPE_SHA1;
8785 salt_type = SALT_TYPE_INTERN;
8786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8788 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8789 dgst_size = DGST_SIZE_4_5;
8790 parse_func = sha1s_parse_hash;
8791 sort_by_digest = sort_by_digest_4_5;
8792 opti_type = OPTI_TYPE_ZERO_BYTE
8793 | OPTI_TYPE_PRECOMPUTE_INIT
8794 | OPTI_TYPE_PRECOMPUTE_MERKLE
8795 | OPTI_TYPE_EARLY_SKIP;
8796 dgst_pos0 = 3;
8797 dgst_pos1 = 4;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 1;
8800 break;
8801
8802 case 5000: hash_type = HASH_TYPE_KECCAK;
8803 salt_type = SALT_TYPE_EMBEDDED;
8804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE
8806 | OPTS_TYPE_PT_ADD01;
8807 kern_type = KERN_TYPE_KECCAK;
8808 dgst_size = DGST_SIZE_8_25;
8809 parse_func = keccak_parse_hash;
8810 sort_by_digest = sort_by_digest_8_25;
8811 opti_type = OPTI_TYPE_ZERO_BYTE
8812 | OPTI_TYPE_USES_BITS_64
8813 | OPTI_TYPE_RAW_HASH;
8814 dgst_pos0 = 2;
8815 dgst_pos1 = 3;
8816 dgst_pos2 = 4;
8817 dgst_pos3 = 5;
8818 break;
8819
8820 case 5100: hash_type = HASH_TYPE_MD5H;
8821 salt_type = SALT_TYPE_NONE;
8822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE
8824 | OPTS_TYPE_PT_ADD80
8825 | OPTS_TYPE_PT_ADDBITS14;
8826 kern_type = KERN_TYPE_MD5H;
8827 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8828 parse_func = md5half_parse_hash;
8829 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8830 opti_type = OPTI_TYPE_ZERO_BYTE
8831 | OPTI_TYPE_RAW_HASH;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 5200: hash_type = HASH_TYPE_SHA256;
8839 salt_type = SALT_TYPE_EMBEDDED;
8840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8842 kern_type = KERN_TYPE_PSAFE3;
8843 dgst_size = DGST_SIZE_4_8;
8844 parse_func = psafe3_parse_hash;
8845 sort_by_digest = sort_by_digest_4_8;
8846 opti_type = OPTI_TYPE_ZERO_BYTE;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 5300: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_ST_ADD80;
8858 kern_type = KERN_TYPE_IKEPSK_MD5;
8859 dgst_size = DGST_SIZE_4_4;
8860 parse_func = ikepsk_md5_parse_hash;
8861 sort_by_digest = sort_by_digest_4_4;
8862 opti_type = OPTI_TYPE_ZERO_BYTE;
8863 dgst_pos0 = 0;
8864 dgst_pos1 = 3;
8865 dgst_pos2 = 2;
8866 dgst_pos3 = 1;
8867 break;
8868
8869 case 5400: hash_type = HASH_TYPE_SHA1;
8870 salt_type = SALT_TYPE_EMBEDDED;
8871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8872 opts_type = OPTS_TYPE_PT_GENERATE_BE
8873 | OPTS_TYPE_ST_ADD80;
8874 kern_type = KERN_TYPE_IKEPSK_SHA1;
8875 dgst_size = DGST_SIZE_4_5;
8876 parse_func = ikepsk_sha1_parse_hash;
8877 sort_by_digest = sort_by_digest_4_5;
8878 opti_type = OPTI_TYPE_ZERO_BYTE;
8879 dgst_pos0 = 3;
8880 dgst_pos1 = 4;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 1;
8883 break;
8884
8885 case 5500: hash_type = HASH_TYPE_NETNTLM;
8886 salt_type = SALT_TYPE_EMBEDDED;
8887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE
8889 | OPTS_TYPE_PT_ADD80
8890 | OPTS_TYPE_PT_ADDBITS14
8891 | OPTS_TYPE_PT_UNICODE
8892 | OPTS_TYPE_ST_HEX;
8893 kern_type = KERN_TYPE_NETNTLMv1;
8894 dgst_size = DGST_SIZE_4_4;
8895 parse_func = netntlmv1_parse_hash;
8896 sort_by_digest = sort_by_digest_4_4;
8897 opti_type = OPTI_TYPE_ZERO_BYTE
8898 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 5600: hash_type = HASH_TYPE_MD5;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE
8909 | OPTS_TYPE_PT_ADD80
8910 | OPTS_TYPE_PT_ADDBITS14
8911 | OPTS_TYPE_PT_UNICODE;
8912 kern_type = KERN_TYPE_NETNTLMv2;
8913 dgst_size = DGST_SIZE_4_4;
8914 parse_func = netntlmv2_parse_hash;
8915 sort_by_digest = sort_by_digest_4_4;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 3;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 1;
8921 break;
8922
8923 case 5700: hash_type = HASH_TYPE_SHA256;
8924 salt_type = SALT_TYPE_NONE;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_BE
8927 | OPTS_TYPE_PT_ADD80
8928 | OPTS_TYPE_PT_ADDBITS15;
8929 kern_type = KERN_TYPE_SHA256;
8930 dgst_size = DGST_SIZE_4_8;
8931 parse_func = cisco4_parse_hash;
8932 sort_by_digest = sort_by_digest_4_8;
8933 opti_type = OPTI_TYPE_ZERO_BYTE
8934 | OPTI_TYPE_PRECOMPUTE_INIT
8935 | OPTI_TYPE_PRECOMPUTE_MERKLE
8936 | OPTI_TYPE_EARLY_SKIP
8937 | OPTI_TYPE_NOT_ITERATED
8938 | OPTI_TYPE_NOT_SALTED
8939 | OPTI_TYPE_RAW_HASH;
8940 dgst_pos0 = 3;
8941 dgst_pos1 = 7;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 6;
8944 break;
8945
8946 case 5800: hash_type = HASH_TYPE_SHA1;
8947 salt_type = SALT_TYPE_INTERN;
8948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8950 | OPTS_TYPE_ST_ADD80;
8951 kern_type = KERN_TYPE_ANDROIDPIN;
8952 dgst_size = DGST_SIZE_4_5;
8953 parse_func = androidpin_parse_hash;
8954 sort_by_digest = sort_by_digest_4_5;
8955 opti_type = OPTI_TYPE_ZERO_BYTE;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8963 salt_type = SALT_TYPE_NONE;
8964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_LE
8966 | OPTS_TYPE_PT_ADD80;
8967 kern_type = KERN_TYPE_RIPEMD160;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = ripemd160_parse_hash;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8979 salt_type = SALT_TYPE_NONE;
8980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_BE
8982 | OPTS_TYPE_PT_ADD80;
8983 kern_type = KERN_TYPE_WHIRLPOOL;
8984 dgst_size = DGST_SIZE_4_16;
8985 parse_func = whirlpool_parse_hash;
8986 sort_by_digest = sort_by_digest_4_16;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_2k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9014 dgst_size = DGST_SIZE_4_5;
9015 parse_func = truecrypt_parse_hash_2k;
9016 sort_by_digest = sort_by_digest_4_5;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9029 dgst_size = DGST_SIZE_4_5;
9030 parse_func = truecrypt_parse_hash_2k;
9031 sort_by_digest = sort_by_digest_4_5;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6221: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_TCSHA512_XTS512;
9044 dgst_size = DGST_SIZE_8_8;
9045 parse_func = truecrypt_parse_hash_1k;
9046 sort_by_digest = sort_by_digest_8_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 6222: hash_type = HASH_TYPE_SHA512;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9059 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9060 dgst_size = DGST_SIZE_8_8;
9061 parse_func = truecrypt_parse_hash_1k;
9062 sort_by_digest = sort_by_digest_8_8;
9063 opti_type = OPTI_TYPE_ZERO_BYTE
9064 | OPTI_TYPE_USES_BITS_64;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 6223: hash_type = HASH_TYPE_SHA512;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9075 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9076 dgst_size = DGST_SIZE_8_8;
9077 parse_func = truecrypt_parse_hash_1k;
9078 sort_by_digest = sort_by_digest_8_8;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_USES_BITS_64;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = truecrypt_parse_hash_1k;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9106 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9107 dgst_size = DGST_SIZE_4_8;
9108 parse_func = truecrypt_parse_hash_1k;
9109 sort_by_digest = sort_by_digest_4_8;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9122 dgst_size = DGST_SIZE_4_8;
9123 parse_func = truecrypt_parse_hash_1k;
9124 sort_by_digest = sort_by_digest_4_8;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9136 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9137 dgst_size = DGST_SIZE_4_5;
9138 parse_func = truecrypt_parse_hash_1k;
9139 sort_by_digest = sort_by_digest_4_5;
9140 opti_type = OPTI_TYPE_ZERO_BYTE;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9151 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9152 dgst_size = DGST_SIZE_4_5;
9153 parse_func = truecrypt_parse_hash_1k;
9154 sort_by_digest = sort_by_digest_4_5;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9167 dgst_size = DGST_SIZE_4_5;
9168 parse_func = truecrypt_parse_hash_1k;
9169 sort_by_digest = sort_by_digest_4_5;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6300: hash_type = HASH_TYPE_MD5;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9181 kern_type = KERN_TYPE_MD5AIX;
9182 dgst_size = DGST_SIZE_4_4;
9183 parse_func = md5aix_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 6400: hash_type = HASH_TYPE_SHA256;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9196 kern_type = KERN_TYPE_SHA256AIX;
9197 dgst_size = DGST_SIZE_4_8;
9198 parse_func = sha256aix_parse_hash;
9199 sort_by_digest = sort_by_digest_4_8;
9200 opti_type = OPTI_TYPE_ZERO_BYTE;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 6500: hash_type = HASH_TYPE_SHA512;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9211 kern_type = KERN_TYPE_SHA512AIX;
9212 dgst_size = DGST_SIZE_8_8;
9213 parse_func = sha512aix_parse_hash;
9214 sort_by_digest = sort_by_digest_8_8;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_USES_BITS_64;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 6600: hash_type = HASH_TYPE_AES;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9227 kern_type = KERN_TYPE_AGILEKEY;
9228 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9229 parse_func = agilekey_parse_hash;
9230 sort_by_digest = sort_by_digest_4_5;
9231 opti_type = OPTI_TYPE_ZERO_BYTE;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 1;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 3;
9236 break;
9237
9238 case 6700: hash_type = HASH_TYPE_SHA1;
9239 salt_type = SALT_TYPE_EMBEDDED;
9240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9242 kern_type = KERN_TYPE_SHA1AIX;
9243 dgst_size = DGST_SIZE_4_5;
9244 parse_func = sha1aix_parse_hash;
9245 sort_by_digest = sort_by_digest_4_5;
9246 opti_type = OPTI_TYPE_ZERO_BYTE;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 6800: hash_type = HASH_TYPE_AES;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9257 kern_type = KERN_TYPE_LASTPASS;
9258 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9259 parse_func = lastpass_parse_hash;
9260 sort_by_digest = sort_by_digest_4_8;
9261 opti_type = OPTI_TYPE_ZERO_BYTE;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 1;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 3;
9266 break;
9267
9268 case 6900: hash_type = HASH_TYPE_GOST;
9269 salt_type = SALT_TYPE_NONE;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9272 kern_type = KERN_TYPE_GOST;
9273 dgst_size = DGST_SIZE_4_8;
9274 parse_func = gost_parse_hash;
9275 sort_by_digest = sort_by_digest_4_8;
9276 opti_type = OPTI_TYPE_ZERO_BYTE;
9277 dgst_pos0 = 0;
9278 dgst_pos1 = 1;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 3;
9281 break;
9282
9283 case 7100: hash_type = HASH_TYPE_SHA512;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9287 kern_type = KERN_TYPE_PBKDF2_SHA512;
9288 dgst_size = DGST_SIZE_8_16;
9289 parse_func = sha512osx_parse_hash;
9290 sort_by_digest = sort_by_digest_8_16;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_USES_BITS_64
9293 | OPTI_TYPE_SLOW_HASH_SIMD;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 7200: hash_type = HASH_TYPE_SHA512;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9304 kern_type = KERN_TYPE_PBKDF2_SHA512;
9305 dgst_size = DGST_SIZE_8_16;
9306 parse_func = sha512grub_parse_hash;
9307 sort_by_digest = sort_by_digest_8_16;
9308 opti_type = OPTI_TYPE_ZERO_BYTE
9309 | OPTI_TYPE_USES_BITS_64
9310 | OPTI_TYPE_SLOW_HASH_SIMD;
9311 dgst_pos0 = 0;
9312 dgst_pos1 = 1;
9313 dgst_pos2 = 2;
9314 dgst_pos3 = 3;
9315 break;
9316
9317 case 7300: hash_type = HASH_TYPE_SHA1;
9318 salt_type = SALT_TYPE_EMBEDDED;
9319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9320 opts_type = OPTS_TYPE_PT_GENERATE_BE
9321 | OPTS_TYPE_ST_ADD80
9322 | OPTS_TYPE_ST_ADDBITS15;
9323 kern_type = KERN_TYPE_RAKP;
9324 dgst_size = DGST_SIZE_4_5;
9325 parse_func = rakp_parse_hash;
9326 sort_by_digest = sort_by_digest_4_5;
9327 opti_type = OPTI_TYPE_ZERO_BYTE
9328 | OPTI_TYPE_NOT_ITERATED;
9329 dgst_pos0 = 3;
9330 dgst_pos1 = 4;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 1;
9333 break;
9334
9335 case 7400: hash_type = HASH_TYPE_SHA256;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9339 kern_type = KERN_TYPE_SHA256CRYPT;
9340 dgst_size = DGST_SIZE_4_8;
9341 parse_func = sha256crypt_parse_hash;
9342 sort_by_digest = sort_by_digest_4_8;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 7500: hash_type = HASH_TYPE_KRB5PA;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9354 kern_type = KERN_TYPE_KRB5PA;
9355 dgst_size = DGST_SIZE_4_4;
9356 parse_func = krb5pa_parse_hash;
9357 sort_by_digest = sort_by_digest_4_4;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_NOT_ITERATED;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 7600: hash_type = HASH_TYPE_SHA1;
9367 salt_type = SALT_TYPE_INTERN;
9368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_BE
9370 | OPTS_TYPE_PT_ADD80
9371 | OPTS_TYPE_PT_ADDBITS15;
9372 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9373 dgst_size = DGST_SIZE_4_5;
9374 parse_func = redmine_parse_hash;
9375 sort_by_digest = sort_by_digest_4_5;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_PRECOMPUTE_INIT
9378 | OPTI_TYPE_EARLY_SKIP
9379 | OPTI_TYPE_NOT_ITERATED
9380 | OPTI_TYPE_PREPENDED_SALT;
9381 dgst_pos0 = 3;
9382 dgst_pos1 = 4;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 1;
9385 break;
9386
9387 case 7700: hash_type = HASH_TYPE_SAPB;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_PT_UPPER
9392 | OPTS_TYPE_ST_UPPER;
9393 kern_type = KERN_TYPE_SAPB;
9394 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9395 parse_func = sapb_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_PRECOMPUTE_INIT
9399 | OPTI_TYPE_NOT_ITERATED;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 7800: hash_type = HASH_TYPE_SAPG;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_BE
9410 | OPTS_TYPE_ST_ADD80
9411 | OPTS_TYPE_ST_UPPER;
9412 kern_type = KERN_TYPE_SAPG;
9413 dgst_size = DGST_SIZE_4_5;
9414 parse_func = sapg_parse_hash;
9415 sort_by_digest = sort_by_digest_4_5;
9416 opti_type = OPTI_TYPE_ZERO_BYTE
9417 | OPTI_TYPE_PRECOMPUTE_INIT
9418 | OPTI_TYPE_NOT_ITERATED;
9419 dgst_pos0 = 3;
9420 dgst_pos1 = 4;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 1;
9423 break;
9424
9425 case 7900: hash_type = HASH_TYPE_SHA512;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9429 kern_type = KERN_TYPE_DRUPAL7;
9430 dgst_size = DGST_SIZE_8_8;
9431 parse_func = drupal7_parse_hash;
9432 sort_by_digest = sort_by_digest_8_8;
9433 opti_type = OPTI_TYPE_ZERO_BYTE
9434 | OPTI_TYPE_USES_BITS_64;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 8000: hash_type = HASH_TYPE_SHA256;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_BE
9445 | OPTS_TYPE_PT_UNICODE
9446 | OPTS_TYPE_ST_ADD80
9447 | OPTS_TYPE_ST_HEX;
9448 kern_type = KERN_TYPE_SYBASEASE;
9449 dgst_size = DGST_SIZE_4_8;
9450 parse_func = sybasease_parse_hash;
9451 sort_by_digest = sort_by_digest_4_8;
9452 opti_type = OPTI_TYPE_ZERO_BYTE
9453 | OPTI_TYPE_PRECOMPUTE_INIT
9454 | OPTI_TYPE_EARLY_SKIP
9455 | OPTI_TYPE_NOT_ITERATED
9456 | OPTI_TYPE_RAW_HASH;
9457 dgst_pos0 = 3;
9458 dgst_pos1 = 7;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 6;
9461 break;
9462
9463 case 8100: hash_type = HASH_TYPE_SHA1;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9467 kern_type = KERN_TYPE_NETSCALER;
9468 dgst_size = DGST_SIZE_4_5;
9469 parse_func = netscaler_parse_hash;
9470 sort_by_digest = sort_by_digest_4_5;
9471 opti_type = OPTI_TYPE_ZERO_BYTE
9472 | OPTI_TYPE_PRECOMPUTE_INIT
9473 | OPTI_TYPE_PRECOMPUTE_MERKLE
9474 | OPTI_TYPE_EARLY_SKIP
9475 | OPTI_TYPE_NOT_ITERATED
9476 | OPTI_TYPE_PREPENDED_SALT
9477 | OPTI_TYPE_RAW_HASH;
9478 dgst_pos0 = 3;
9479 dgst_pos1 = 4;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 1;
9482 break;
9483
9484 case 8200: hash_type = HASH_TYPE_SHA256;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9488 kern_type = KERN_TYPE_CLOUDKEY;
9489 dgst_size = DGST_SIZE_4_8;
9490 parse_func = cloudkey_parse_hash;
9491 sort_by_digest = sort_by_digest_4_8;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 8300: hash_type = HASH_TYPE_SHA1;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_BE
9503 | OPTS_TYPE_ST_HEX
9504 | OPTS_TYPE_ST_ADD80;
9505 kern_type = KERN_TYPE_NSEC3;
9506 dgst_size = DGST_SIZE_4_5;
9507 parse_func = nsec3_parse_hash;
9508 sort_by_digest = sort_by_digest_4_5;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 3;
9511 dgst_pos1 = 4;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 1;
9514 break;
9515
9516 case 8400: hash_type = HASH_TYPE_SHA1;
9517 salt_type = SALT_TYPE_INTERN;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_BE
9520 | OPTS_TYPE_PT_ADD80
9521 | OPTS_TYPE_PT_ADDBITS15;
9522 kern_type = KERN_TYPE_WBB3;
9523 dgst_size = DGST_SIZE_4_5;
9524 parse_func = wbb3_parse_hash;
9525 sort_by_digest = sort_by_digest_4_5;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_PRECOMPUTE_INIT
9528 | OPTI_TYPE_NOT_ITERATED;
9529 dgst_pos0 = 3;
9530 dgst_pos1 = 4;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 1;
9533 break;
9534
9535 case 8500: hash_type = HASH_TYPE_DESRACF;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE
9539 | OPTS_TYPE_ST_UPPER;
9540 kern_type = KERN_TYPE_RACF;
9541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9542 parse_func = racf_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 8600: hash_type = HASH_TYPE_LOTUS5;
9553 salt_type = SALT_TYPE_NONE;
9554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9556 kern_type = KERN_TYPE_LOTUS5;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = lotus5_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_EARLY_SKIP
9561 | OPTI_TYPE_NOT_ITERATED
9562 | OPTI_TYPE_NOT_SALTED
9563 | OPTI_TYPE_RAW_HASH;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 8700: hash_type = HASH_TYPE_LOTUS6;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9574 kern_type = KERN_TYPE_LOTUS6;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = lotus6_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_EARLY_SKIP
9579 | OPTI_TYPE_NOT_ITERATED
9580 | OPTI_TYPE_RAW_HASH;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9591 kern_type = KERN_TYPE_ANDROIDFDE;
9592 dgst_size = DGST_SIZE_4_4;
9593 parse_func = androidfde_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4;
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 8900: hash_type = HASH_TYPE_SCRYPT;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9606 kern_type = KERN_TYPE_SCRYPT;
9607 dgst_size = DGST_SIZE_4_8;
9608 parse_func = scrypt_parse_hash;
9609 sort_by_digest = sort_by_digest_4_8;
9610 opti_type = OPTI_TYPE_ZERO_BYTE;
9611 dgst_pos0 = 0;
9612 dgst_pos1 = 1;
9613 dgst_pos2 = 2;
9614 dgst_pos3 = 3;
9615 break;
9616
9617 case 9000: hash_type = HASH_TYPE_SHA1;
9618 salt_type = SALT_TYPE_EMBEDDED;
9619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9620 opts_type = OPTS_TYPE_PT_GENERATE_LE
9621 | OPTS_TYPE_ST_GENERATE_LE;
9622 kern_type = KERN_TYPE_PSAFE2;
9623 dgst_size = DGST_SIZE_4_5;
9624 parse_func = psafe2_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9100: hash_type = HASH_TYPE_LOTUS8;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9637 kern_type = KERN_TYPE_LOTUS8;
9638 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9639 parse_func = lotus8_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 9200: hash_type = HASH_TYPE_SHA256;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9652 kern_type = KERN_TYPE_PBKDF2_SHA256;
9653 dgst_size = DGST_SIZE_4_32;
9654 parse_func = cisco8_parse_hash;
9655 sort_by_digest = sort_by_digest_4_32;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_SLOW_HASH_SIMD;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 9300: hash_type = HASH_TYPE_SCRYPT;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_SCRYPT;
9669 dgst_size = DGST_SIZE_4_8;
9670 parse_func = cisco9_parse_hash;
9671 sort_by_digest = sort_by_digest_4_8;
9672 opti_type = OPTI_TYPE_ZERO_BYTE;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9683 kern_type = KERN_TYPE_OFFICE2007;
9684 dgst_size = DGST_SIZE_4_4;
9685 parse_func = office2007_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4;
9687 opti_type = OPTI_TYPE_ZERO_BYTE;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_OFFICE2010;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = office2010_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_OFFICE2013;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = office2013_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_PT_ADD80
9729 | OPTS_TYPE_PT_UNICODE;
9730 kern_type = KERN_TYPE_OLDOFFICE01;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = oldoffice01_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_PRECOMPUTE_INIT
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9744 salt_type = SALT_TYPE_EMBEDDED;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_LE
9747 | OPTS_TYPE_PT_ADD80;
9748 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = oldoffice01cm1_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_PRECOMPUTE_INIT
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE
9765 | OPTS_TYPE_PT_ADD80
9766 | OPTS_TYPE_PT_UNICODE
9767 | OPTS_TYPE_PT_NEVERCRACK;
9768 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9769 dgst_size = DGST_SIZE_4_4;
9770 parse_func = oldoffice01cm2_parse_hash;
9771 sort_by_digest = sort_by_digest_4_4;
9772 opti_type = OPTI_TYPE_ZERO_BYTE
9773 | OPTI_TYPE_PRECOMPUTE_INIT
9774 | OPTI_TYPE_NOT_ITERATED;
9775 dgst_pos0 = 0;
9776 dgst_pos1 = 1;
9777 dgst_pos2 = 2;
9778 dgst_pos3 = 3;
9779 break;
9780
9781 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9782 salt_type = SALT_TYPE_EMBEDDED;
9783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9784 opts_type = OPTS_TYPE_PT_GENERATE_BE
9785 | OPTS_TYPE_PT_ADD80
9786 | OPTS_TYPE_PT_UNICODE;
9787 kern_type = KERN_TYPE_OLDOFFICE34;
9788 dgst_size = DGST_SIZE_4_4;
9789 parse_func = oldoffice34_parse_hash;
9790 sort_by_digest = sort_by_digest_4_4;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_PRECOMPUTE_INIT
9793 | OPTI_TYPE_NOT_ITERATED;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9804 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9805 dgst_size = DGST_SIZE_4_4;
9806 parse_func = oldoffice34cm1_parse_hash;
9807 sort_by_digest = sort_by_digest_4_4;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_PRECOMPUTE_INIT
9810 | OPTI_TYPE_NOT_ITERATED;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_BE
9821 | OPTS_TYPE_PT_ADD80
9822 | OPTS_TYPE_PT_UNICODE
9823 | OPTS_TYPE_PT_NEVERCRACK;
9824 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = oldoffice34cm2_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_PRECOMPUTE_INIT
9830 | OPTI_TYPE_NOT_ITERATED;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 9900: hash_type = HASH_TYPE_MD5;
9838 salt_type = SALT_TYPE_NONE;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9841 kern_type = KERN_TYPE_RADMIN2;
9842 dgst_size = DGST_SIZE_4_4;
9843 parse_func = radmin2_parse_hash;
9844 sort_by_digest = sort_by_digest_4_4;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_PRECOMPUTE_INIT
9847 | OPTI_TYPE_EARLY_SKIP
9848 | OPTI_TYPE_NOT_ITERATED
9849 | OPTI_TYPE_NOT_SALTED;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 3;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 1;
9854 break;
9855
9856 case 10000: hash_type = HASH_TYPE_SHA256;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9860 kern_type = KERN_TYPE_PBKDF2_SHA256;
9861 dgst_size = DGST_SIZE_4_32;
9862 parse_func = djangopbkdf2_parse_hash;
9863 sort_by_digest = sort_by_digest_4_32;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_SLOW_HASH_SIMD;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 1;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 3;
9870 break;
9871
9872 case 10100: hash_type = HASH_TYPE_SIPHASH;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9876 kern_type = KERN_TYPE_SIPHASH;
9877 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9878 parse_func = siphash_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9880 opti_type = OPTI_TYPE_ZERO_BYTE
9881 | OPTI_TYPE_NOT_ITERATED
9882 | OPTI_TYPE_RAW_HASH;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 1;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 3;
9887 break;
9888
9889 case 10200: hash_type = HASH_TYPE_MD5;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE
9893 | OPTS_TYPE_ST_ADD80
9894 | OPTS_TYPE_ST_ADDBITS14;
9895 kern_type = KERN_TYPE_HMACMD5_PW;
9896 dgst_size = DGST_SIZE_4_4;
9897 parse_func = crammd5_parse_hash;
9898 sort_by_digest = sort_by_digest_4_4;
9899 opti_type = OPTI_TYPE_ZERO_BYTE
9900 | OPTI_TYPE_NOT_ITERATED;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 3;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 1;
9905 break;
9906
9907 case 10300: hash_type = HASH_TYPE_SHA1;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9911 kern_type = KERN_TYPE_SAPH_SHA1;
9912 dgst_size = DGST_SIZE_4_5;
9913 parse_func = saph_sha1_parse_hash;
9914 sort_by_digest = sort_by_digest_4_5;
9915 opti_type = OPTI_TYPE_ZERO_BYTE;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 10400: hash_type = HASH_TYPE_PDFU16;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_PDF11;
9927 dgst_size = DGST_SIZE_4_4;
9928 parse_func = pdf11_parse_hash;
9929 sort_by_digest = sort_by_digest_4_4;
9930 opti_type = OPTI_TYPE_ZERO_BYTE
9931 | OPTI_TYPE_NOT_ITERATED;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 10410: hash_type = HASH_TYPE_PDFU16;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9942 kern_type = KERN_TYPE_PDF11CM1;
9943 dgst_size = DGST_SIZE_4_4;
9944 parse_func = pdf11cm1_parse_hash;
9945 sort_by_digest = sort_by_digest_4_4;
9946 opti_type = OPTI_TYPE_ZERO_BYTE
9947 | OPTI_TYPE_NOT_ITERATED;
9948 dgst_pos0 = 0;
9949 dgst_pos1 = 1;
9950 dgst_pos2 = 2;
9951 dgst_pos3 = 3;
9952 break;
9953
9954 case 10420: hash_type = HASH_TYPE_PDFU16;
9955 salt_type = SALT_TYPE_EMBEDDED;
9956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9958 kern_type = KERN_TYPE_PDF11CM2;
9959 dgst_size = DGST_SIZE_4_4;
9960 parse_func = pdf11cm2_parse_hash;
9961 sort_by_digest = sort_by_digest_4_4;
9962 opti_type = OPTI_TYPE_ZERO_BYTE
9963 | OPTI_TYPE_NOT_ITERATED;
9964 dgst_pos0 = 0;
9965 dgst_pos1 = 1;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 3;
9968 break;
9969
9970 case 10500: hash_type = HASH_TYPE_PDFU16;
9971 salt_type = SALT_TYPE_EMBEDDED;
9972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9974 kern_type = KERN_TYPE_PDF14;
9975 dgst_size = DGST_SIZE_4_4;
9976 parse_func = pdf14_parse_hash;
9977 sort_by_digest = sort_by_digest_4_4;
9978 opti_type = OPTI_TYPE_ZERO_BYTE
9979 | OPTI_TYPE_NOT_ITERATED;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 10600: hash_type = HASH_TYPE_SHA256;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_BE
9990 | OPTS_TYPE_ST_ADD80
9991 | OPTS_TYPE_ST_ADDBITS15
9992 | OPTS_TYPE_HASH_COPY;
9993 kern_type = KERN_TYPE_SHA256_PWSLT;
9994 dgst_size = DGST_SIZE_4_8;
9995 parse_func = pdf17l3_parse_hash;
9996 sort_by_digest = sort_by_digest_4_8;
9997 opti_type = OPTI_TYPE_ZERO_BYTE
9998 | OPTI_TYPE_PRECOMPUTE_INIT
9999 | OPTI_TYPE_PRECOMPUTE_MERKLE
10000 | OPTI_TYPE_EARLY_SKIP
10001 | OPTI_TYPE_NOT_ITERATED
10002 | OPTI_TYPE_APPENDED_SALT
10003 | OPTI_TYPE_RAW_HASH;
10004 dgst_pos0 = 3;
10005 dgst_pos1 = 7;
10006 dgst_pos2 = 2;
10007 dgst_pos3 = 6;
10008 break;
10009
10010 case 10700: hash_type = HASH_TYPE_PDFU32;
10011 salt_type = SALT_TYPE_EMBEDDED;
10012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10013 opts_type = OPTS_TYPE_PT_GENERATE_LE
10014 | OPTS_TYPE_HASH_COPY;
10015 kern_type = KERN_TYPE_PDF17L8;
10016 dgst_size = DGST_SIZE_4_8;
10017 parse_func = pdf17l8_parse_hash;
10018 sort_by_digest = sort_by_digest_4_8;
10019 opti_type = OPTI_TYPE_ZERO_BYTE
10020 | OPTI_TYPE_NOT_ITERATED;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 10800: hash_type = HASH_TYPE_SHA384;
10028 salt_type = SALT_TYPE_NONE;
10029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_BE
10031 | OPTS_TYPE_PT_ADD80
10032 | OPTS_TYPE_PT_ADDBITS15;
10033 kern_type = KERN_TYPE_SHA384;
10034 dgst_size = DGST_SIZE_8_8;
10035 parse_func = sha384_parse_hash;
10036 sort_by_digest = sort_by_digest_8_8;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_PRECOMPUTE_INIT
10039 | OPTI_TYPE_PRECOMPUTE_MERKLE
10040 | OPTI_TYPE_EARLY_SKIP
10041 | OPTI_TYPE_NOT_ITERATED
10042 | OPTI_TYPE_NOT_SALTED
10043 | OPTI_TYPE_USES_BITS_64
10044 | OPTI_TYPE_RAW_HASH;
10045 dgst_pos0 = 6;
10046 dgst_pos1 = 7;
10047 dgst_pos2 = 4;
10048 dgst_pos3 = 5;
10049 break;
10050
10051 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE
10055 | OPTS_TYPE_ST_BASE64
10056 | OPTS_TYPE_HASH_COPY;
10057 kern_type = KERN_TYPE_PBKDF2_SHA256;
10058 dgst_size = DGST_SIZE_4_32;
10059 parse_func = pbkdf2_sha256_parse_hash;
10060 sort_by_digest = sort_by_digest_4_32;
10061 opti_type = OPTI_TYPE_ZERO_BYTE
10062 | OPTI_TYPE_SLOW_HASH_SIMD;
10063 dgst_pos0 = 0;
10064 dgst_pos1 = 1;
10065 dgst_pos2 = 2;
10066 dgst_pos3 = 3;
10067 break;
10068
10069 case 11000: hash_type = HASH_TYPE_MD5;
10070 salt_type = SALT_TYPE_INTERN;
10071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_LE
10073 | OPTS_TYPE_PT_ADD80;
10074 kern_type = KERN_TYPE_PRESTASHOP;
10075 dgst_size = DGST_SIZE_4_4;
10076 parse_func = prestashop_parse_hash;
10077 sort_by_digest = sort_by_digest_4_4;
10078 opti_type = OPTI_TYPE_ZERO_BYTE
10079 | OPTI_TYPE_PRECOMPUTE_INIT
10080 | OPTI_TYPE_NOT_ITERATED
10081 | OPTI_TYPE_PREPENDED_SALT;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 3;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 1;
10086 break;
10087
10088 case 11100: hash_type = HASH_TYPE_MD5;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE
10092 | OPTS_TYPE_ST_ADD80;
10093 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = postgresql_auth_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE
10098 | OPTI_TYPE_PRECOMPUTE_INIT
10099 | OPTI_TYPE_PRECOMPUTE_MERKLE
10100 | OPTI_TYPE_EARLY_SKIP;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 3;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 1;
10105 break;
10106
10107 case 11200: hash_type = HASH_TYPE_SHA1;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_BE
10111 | OPTS_TYPE_PT_ADD80
10112 | OPTS_TYPE_ST_HEX;
10113 kern_type = KERN_TYPE_MYSQL_AUTH;
10114 dgst_size = DGST_SIZE_4_5;
10115 parse_func = mysql_auth_parse_hash;
10116 sort_by_digest = sort_by_digest_4_5;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_EARLY_SKIP;
10119 dgst_pos0 = 3;
10120 dgst_pos1 = 4;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 1;
10123 break;
10124
10125 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE
10129 | OPTS_TYPE_ST_HEX
10130 | OPTS_TYPE_ST_ADD80;
10131 kern_type = KERN_TYPE_BITCOIN_WALLET;
10132 dgst_size = DGST_SIZE_4_4;
10133 parse_func = bitcoin_wallet_parse_hash;
10134 sort_by_digest = sort_by_digest_4_4;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 11400: hash_type = HASH_TYPE_MD5;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_PT_ADD80
10147 | OPTS_TYPE_HASH_COPY;
10148 kern_type = KERN_TYPE_SIP_AUTH;
10149 dgst_size = DGST_SIZE_4_4;
10150 parse_func = sip_auth_parse_hash;
10151 sort_by_digest = sort_by_digest_4_4;
10152 opti_type = OPTI_TYPE_ZERO_BYTE;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 3;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 1;
10157 break;
10158
10159 case 11500: hash_type = HASH_TYPE_CRC32;
10160 salt_type = SALT_TYPE_INTERN;
10161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE
10163 | OPTS_TYPE_ST_GENERATE_LE
10164 | OPTS_TYPE_ST_HEX;
10165 kern_type = KERN_TYPE_CRC32;
10166 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10167 parse_func = crc32_parse_hash;
10168 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10169 opti_type = OPTI_TYPE_ZERO_BYTE;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 11600: hash_type = HASH_TYPE_AES;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_LE
10180 | OPTS_TYPE_PT_NEVERCRACK;
10181 kern_type = KERN_TYPE_SEVEN_ZIP;
10182 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10183 parse_func = seven_zip_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10193 salt_type = SALT_TYPE_NONE;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE
10196 | OPTS_TYPE_PT_ADD01;
10197 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10198 dgst_size = DGST_SIZE_4_8;
10199 parse_func = gost2012sbog_256_parse_hash;
10200 sort_by_digest = sort_by_digest_4_8;
10201 opti_type = OPTI_TYPE_ZERO_BYTE;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10209 salt_type = SALT_TYPE_NONE;
10210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE
10212 | OPTS_TYPE_PT_ADD01;
10213 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10214 dgst_size = DGST_SIZE_4_16;
10215 parse_func = gost2012sbog_512_parse_hash;
10216 sort_by_digest = sort_by_digest_4_16;
10217 opti_type = OPTI_TYPE_ZERO_BYTE;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE
10228 | OPTS_TYPE_ST_BASE64
10229 | OPTS_TYPE_HASH_COPY;
10230 kern_type = KERN_TYPE_PBKDF2_MD5;
10231 dgst_size = DGST_SIZE_4_32;
10232 parse_func = pbkdf2_md5_parse_hash;
10233 sort_by_digest = sort_by_digest_4_32;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_SLOW_HASH_SIMD;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE
10246 | OPTS_TYPE_ST_BASE64
10247 | OPTS_TYPE_HASH_COPY;
10248 kern_type = KERN_TYPE_PBKDF2_SHA1;
10249 dgst_size = DGST_SIZE_4_32;
10250 parse_func = pbkdf2_sha1_parse_hash;
10251 sort_by_digest = sort_by_digest_4_32;
10252 opti_type = OPTI_TYPE_ZERO_BYTE
10253 | OPTI_TYPE_SLOW_HASH_SIMD;
10254 dgst_pos0 = 0;
10255 dgst_pos1 = 1;
10256 dgst_pos2 = 2;
10257 dgst_pos3 = 3;
10258 break;
10259
10260 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10261 salt_type = SALT_TYPE_EMBEDDED;
10262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10263 opts_type = OPTS_TYPE_PT_GENERATE_LE
10264 | OPTS_TYPE_ST_BASE64
10265 | OPTS_TYPE_HASH_COPY;
10266 kern_type = KERN_TYPE_PBKDF2_SHA512;
10267 dgst_size = DGST_SIZE_8_16;
10268 parse_func = pbkdf2_sha512_parse_hash;
10269 sort_by_digest = sort_by_digest_8_16;
10270 opti_type = OPTI_TYPE_ZERO_BYTE
10271 | OPTI_TYPE_USES_BITS_64
10272 | OPTI_TYPE_SLOW_HASH_SIMD;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 1;
10275 dgst_pos2 = 2;
10276 dgst_pos3 = 3;
10277 break;
10278
10279 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10280 salt_type = SALT_TYPE_EMBEDDED;
10281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10283 kern_type = KERN_TYPE_ECRYPTFS;
10284 dgst_size = DGST_SIZE_8_8;
10285 parse_func = ecryptfs_parse_hash;
10286 sort_by_digest = sort_by_digest_8_8;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_USES_BITS_64;
10289 dgst_pos0 = 0;
10290 dgst_pos1 = 1;
10291 dgst_pos2 = 2;
10292 dgst_pos3 = 3;
10293 break;
10294
10295 case 12300: hash_type = HASH_TYPE_ORACLET;
10296 salt_type = SALT_TYPE_EMBEDDED;
10297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10298 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10299 kern_type = KERN_TYPE_ORACLET;
10300 dgst_size = DGST_SIZE_8_16;
10301 parse_func = oraclet_parse_hash;
10302 sort_by_digest = sort_by_digest_8_16;
10303 opti_type = OPTI_TYPE_ZERO_BYTE
10304 | OPTI_TYPE_USES_BITS_64;
10305 dgst_pos0 = 0;
10306 dgst_pos1 = 1;
10307 dgst_pos2 = 2;
10308 dgst_pos3 = 3;
10309 break;
10310
10311 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10312 salt_type = SALT_TYPE_EMBEDDED;
10313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10314 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10315 kern_type = KERN_TYPE_BSDICRYPT;
10316 dgst_size = DGST_SIZE_4_4;
10317 parse_func = bsdicrypt_parse_hash;
10318 sort_by_digest = sort_by_digest_4_4;
10319 opti_type = OPTI_TYPE_ZERO_BYTE
10320 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10321 dgst_pos0 = 0;
10322 dgst_pos1 = 1;
10323 dgst_pos2 = 2;
10324 dgst_pos3 = 3;
10325 break;
10326
10327 case 12500: hash_type = HASH_TYPE_RAR3HP;
10328 salt_type = SALT_TYPE_EMBEDDED;
10329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10331 kern_type = KERN_TYPE_RAR3;
10332 dgst_size = DGST_SIZE_4_4;
10333 parse_func = rar3hp_parse_hash;
10334 sort_by_digest = sort_by_digest_4_4;
10335 opti_type = OPTI_TYPE_ZERO_BYTE;
10336 dgst_pos0 = 0;
10337 dgst_pos1 = 1;
10338 dgst_pos2 = 2;
10339 dgst_pos3 = 3;
10340 break;
10341
10342 case 12600: hash_type = HASH_TYPE_SHA256;
10343 salt_type = SALT_TYPE_INTERN;
10344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10345 opts_type = OPTS_TYPE_PT_GENERATE_BE
10346 | OPTS_TYPE_PT_ADD80;
10347 kern_type = KERN_TYPE_CF10;
10348 dgst_size = DGST_SIZE_4_8;
10349 parse_func = cf10_parse_hash;
10350 sort_by_digest = sort_by_digest_4_8;
10351 opti_type = OPTI_TYPE_ZERO_BYTE
10352 | OPTI_TYPE_PRECOMPUTE_INIT
10353 | OPTI_TYPE_EARLY_SKIP
10354 | OPTI_TYPE_NOT_ITERATED;
10355 dgst_pos0 = 3;
10356 dgst_pos1 = 7;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 6;
10359 break;
10360
10361 case 12700: hash_type = HASH_TYPE_AES;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE
10365 | OPTS_TYPE_HASH_COPY;
10366 kern_type = KERN_TYPE_MYWALLET;
10367 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10368 parse_func = mywallet_parse_hash;
10369 sort_by_digest = sort_by_digest_4_5;
10370 opti_type = OPTI_TYPE_ZERO_BYTE;
10371 dgst_pos0 = 0;
10372 dgst_pos1 = 1;
10373 dgst_pos2 = 2;
10374 dgst_pos3 = 3;
10375 break;
10376
10377 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10378 salt_type = SALT_TYPE_EMBEDDED;
10379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10381 kern_type = KERN_TYPE_MS_DRSR;
10382 dgst_size = DGST_SIZE_4_8;
10383 parse_func = ms_drsr_parse_hash;
10384 sort_by_digest = sort_by_digest_4_8;
10385 opti_type = OPTI_TYPE_ZERO_BYTE;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10396 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10397 dgst_size = DGST_SIZE_4_8;
10398 parse_func = androidfde_samsung_parse_hash;
10399 sort_by_digest = sort_by_digest_4_8;
10400 opti_type = OPTI_TYPE_ZERO_BYTE;
10401 dgst_pos0 = 0;
10402 dgst_pos1 = 1;
10403 dgst_pos2 = 2;
10404 dgst_pos3 = 3;
10405 break;
10406
10407 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10408 salt_type = SALT_TYPE_EMBEDDED;
10409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10410 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10411 kern_type = KERN_TYPE_RAR5;
10412 dgst_size = DGST_SIZE_4_4;
10413 parse_func = rar5_parse_hash;
10414 sort_by_digest = sort_by_digest_4_4;
10415 opti_type = OPTI_TYPE_ZERO_BYTE;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10423 salt_type = SALT_TYPE_EMBEDDED;
10424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10426 kern_type = KERN_TYPE_KRB5TGS;
10427 dgst_size = DGST_SIZE_4_4;
10428 parse_func = krb5tgs_parse_hash;
10429 sort_by_digest = sort_by_digest_4_4;
10430 opti_type = OPTI_TYPE_ZERO_BYTE
10431 | OPTI_TYPE_NOT_ITERATED;
10432 dgst_pos0 = 0;
10433 dgst_pos1 = 1;
10434 dgst_pos2 = 2;
10435 dgst_pos3 = 3;
10436 break;
10437
10438 case 13200: hash_type = HASH_TYPE_AES;
10439 salt_type = SALT_TYPE_EMBEDDED;
10440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10442 kern_type = KERN_TYPE_AXCRYPT;
10443 dgst_size = DGST_SIZE_4_4;
10444 parse_func = axcrypt_parse_hash;
10445 sort_by_digest = sort_by_digest_4_4;
10446 opti_type = OPTI_TYPE_ZERO_BYTE;
10447 dgst_pos0 = 0;
10448 dgst_pos1 = 1;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 3;
10451 break;
10452
10453 case 13300: hash_type = HASH_TYPE_SHA1;
10454 salt_type = SALT_TYPE_NONE;
10455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_BE
10457 | OPTS_TYPE_PT_ADD80
10458 | OPTS_TYPE_PT_ADDBITS15;
10459 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10460 dgst_size = DGST_SIZE_4_5;
10461 parse_func = sha1axcrypt_parse_hash;
10462 sort_by_digest = sort_by_digest_4_5;
10463 opti_type = OPTI_TYPE_ZERO_BYTE
10464 | OPTI_TYPE_PRECOMPUTE_INIT
10465 | OPTI_TYPE_EARLY_SKIP
10466 | OPTI_TYPE_NOT_ITERATED
10467 | OPTI_TYPE_NOT_SALTED;
10468 dgst_pos0 = 0;
10469 dgst_pos1 = 4;
10470 dgst_pos2 = 3;
10471 dgst_pos3 = 2;
10472 break;
10473
10474 case 13400: hash_type = HASH_TYPE_AES;
10475 salt_type = SALT_TYPE_EMBEDDED;
10476 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10477 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10478 kern_type = KERN_TYPE_KEEPASS;
10479 dgst_size = DGST_SIZE_4_4;
10480 parse_func = keepass_parse_hash;
10481 sort_by_digest = sort_by_digest_4_4;
10482 opti_type = OPTI_TYPE_ZERO_BYTE;
10483 dgst_pos0 = 0;
10484 dgst_pos1 = 1;
10485 dgst_pos2 = 2;
10486 dgst_pos3 = 3;
10487 break;
10488
10489 case 13500: hash_type = HASH_TYPE_SHA1;
10490 salt_type = SALT_TYPE_EMBEDDED;
10491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10492 opts_type = OPTS_TYPE_PT_GENERATE_BE
10493 | OPTS_TYPE_PT_UNICODE
10494 | OPTS_TYPE_PT_ADD80;
10495 kern_type = KERN_TYPE_PSTOKEN;
10496 dgst_size = DGST_SIZE_4_5;
10497 parse_func = pstoken_parse_hash;
10498 sort_by_digest = sort_by_digest_4_5;
10499 opti_type = OPTI_TYPE_ZERO_BYTE
10500 | OPTI_TYPE_PRECOMPUTE_INIT
10501 | OPTI_TYPE_EARLY_SKIP
10502 | OPTI_TYPE_NOT_ITERATED
10503 | OPTI_TYPE_PREPENDED_SALT
10504 | OPTI_TYPE_RAW_HASH;
10505 dgst_pos0 = 3;
10506 dgst_pos1 = 4;
10507 dgst_pos2 = 2;
10508 dgst_pos3 = 1;
10509 break;
10510
10511 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10512 salt_type = SALT_TYPE_EMBEDDED;
10513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10515 kern_type = KERN_TYPE_ZIP2;
10516 dgst_size = DGST_SIZE_4_4;
10517 parse_func = zip2_parse_hash;
10518 sort_by_digest = sort_by_digest_4_4;
10519 opti_type = OPTI_TYPE_ZERO_BYTE;
10520 dgst_pos0 = 0;
10521 dgst_pos1 = 1;
10522 dgst_pos2 = 2;
10523 dgst_pos3 = 3;
10524 break;
10525
10526 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10527 salt_type = SALT_TYPE_EMBEDDED;
10528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10530 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10531 dgst_size = DGST_SIZE_4_5;
10532 parse_func = veracrypt_parse_hash_655331;
10533 sort_by_digest = sort_by_digest_4_5;
10534 opti_type = OPTI_TYPE_ZERO_BYTE;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10545 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10546 dgst_size = DGST_SIZE_4_5;
10547 parse_func = veracrypt_parse_hash_655331;
10548 sort_by_digest = sort_by_digest_4_5;
10549 opti_type = OPTI_TYPE_ZERO_BYTE;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10560 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10561 dgst_size = DGST_SIZE_4_5;
10562 parse_func = veracrypt_parse_hash_655331;
10563 sort_by_digest = sort_by_digest_4_5;
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 13721: hash_type = HASH_TYPE_SHA512;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10575 kern_type = KERN_TYPE_TCSHA512_XTS512;
10576 dgst_size = DGST_SIZE_8_8;
10577 parse_func = veracrypt_parse_hash_500000;
10578 sort_by_digest = sort_by_digest_8_8;
10579 opti_type = OPTI_TYPE_ZERO_BYTE
10580 | OPTI_TYPE_USES_BITS_64;
10581 dgst_pos0 = 0;
10582 dgst_pos1 = 1;
10583 dgst_pos2 = 2;
10584 dgst_pos3 = 3;
10585 break;
10586
10587 case 13722: hash_type = HASH_TYPE_SHA512;
10588 salt_type = SALT_TYPE_EMBEDDED;
10589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10590 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10591 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10592 dgst_size = DGST_SIZE_8_8;
10593 parse_func = veracrypt_parse_hash_500000;
10594 sort_by_digest = sort_by_digest_8_8;
10595 opti_type = OPTI_TYPE_ZERO_BYTE
10596 | OPTI_TYPE_USES_BITS_64;
10597 dgst_pos0 = 0;
10598 dgst_pos1 = 1;
10599 dgst_pos2 = 2;
10600 dgst_pos3 = 3;
10601 break;
10602
10603 case 13723: hash_type = HASH_TYPE_SHA512;
10604 salt_type = SALT_TYPE_EMBEDDED;
10605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10606 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10607 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10608 dgst_size = DGST_SIZE_8_8;
10609 parse_func = veracrypt_parse_hash_500000;
10610 sort_by_digest = sort_by_digest_8_8;
10611 opti_type = OPTI_TYPE_ZERO_BYTE
10612 | OPTI_TYPE_USES_BITS_64;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10623 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_500000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10638 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10639 dgst_size = DGST_SIZE_4_8;
10640 parse_func = veracrypt_parse_hash_500000;
10641 sort_by_digest = sort_by_digest_4_8;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10650 salt_type = SALT_TYPE_EMBEDDED;
10651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10653 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10654 dgst_size = DGST_SIZE_4_8;
10655 parse_func = veracrypt_parse_hash_500000;
10656 sort_by_digest = sort_by_digest_4_8;
10657 opti_type = OPTI_TYPE_ZERO_BYTE;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10668 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10669 dgst_size = DGST_SIZE_4_5;
10670 parse_func = veracrypt_parse_hash_327661;
10671 sort_by_digest = sort_by_digest_4_5;
10672 opti_type = OPTI_TYPE_ZERO_BYTE;
10673 dgst_pos0 = 0;
10674 dgst_pos1 = 1;
10675 dgst_pos2 = 2;
10676 dgst_pos3 = 3;
10677 break;
10678
10679 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10680 salt_type = SALT_TYPE_EMBEDDED;
10681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10683 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10684 dgst_size = DGST_SIZE_4_5;
10685 parse_func = veracrypt_parse_hash_327661;
10686 sort_by_digest = sort_by_digest_4_5;
10687 opti_type = OPTI_TYPE_ZERO_BYTE;
10688 dgst_pos0 = 0;
10689 dgst_pos1 = 1;
10690 dgst_pos2 = 2;
10691 dgst_pos3 = 3;
10692 break;
10693
10694 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10695 salt_type = SALT_TYPE_EMBEDDED;
10696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10698 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10699 dgst_size = DGST_SIZE_4_5;
10700 parse_func = veracrypt_parse_hash_327661;
10701 sort_by_digest = sort_by_digest_4_5;
10702 opti_type = OPTI_TYPE_ZERO_BYTE;
10703 dgst_pos0 = 0;
10704 dgst_pos1 = 1;
10705 dgst_pos2 = 2;
10706 dgst_pos3 = 3;
10707 break;
10708
10709 case 13751: hash_type = HASH_TYPE_SHA256;
10710 salt_type = SALT_TYPE_EMBEDDED;
10711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10713 kern_type = KERN_TYPE_VCSHA256_XTS512;
10714 dgst_size = DGST_SIZE_4_8;
10715 parse_func = veracrypt_parse_hash_500000;
10716 sort_by_digest = sort_by_digest_4_8;
10717 opti_type = OPTI_TYPE_ZERO_BYTE;
10718 dgst_pos0 = 0;
10719 dgst_pos1 = 1;
10720 dgst_pos2 = 2;
10721 dgst_pos3 = 3;
10722 break;
10723
10724 case 13752: hash_type = HASH_TYPE_SHA256;
10725 salt_type = SALT_TYPE_EMBEDDED;
10726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10727 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10728 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10729 dgst_size = DGST_SIZE_4_8;
10730 parse_func = veracrypt_parse_hash_500000;
10731 sort_by_digest = sort_by_digest_4_8;
10732 opti_type = OPTI_TYPE_ZERO_BYTE;
10733 dgst_pos0 = 0;
10734 dgst_pos1 = 1;
10735 dgst_pos2 = 2;
10736 dgst_pos3 = 3;
10737 break;
10738
10739 case 13753: hash_type = HASH_TYPE_SHA256;
10740 salt_type = SALT_TYPE_EMBEDDED;
10741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10743 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10744 dgst_size = DGST_SIZE_4_8;
10745 parse_func = veracrypt_parse_hash_500000;
10746 sort_by_digest = sort_by_digest_4_8;
10747 opti_type = OPTI_TYPE_ZERO_BYTE;
10748 dgst_pos0 = 0;
10749 dgst_pos1 = 1;
10750 dgst_pos2 = 2;
10751 dgst_pos3 = 3;
10752 break;
10753
10754 case 13761: hash_type = HASH_TYPE_SHA256;
10755 salt_type = SALT_TYPE_EMBEDDED;
10756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10757 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10758 kern_type = KERN_TYPE_VCSHA256_XTS512;
10759 dgst_size = DGST_SIZE_4_8;
10760 parse_func = veracrypt_parse_hash_200000;
10761 sort_by_digest = sort_by_digest_4_8;
10762 opti_type = OPTI_TYPE_ZERO_BYTE;
10763 dgst_pos0 = 0;
10764 dgst_pos1 = 1;
10765 dgst_pos2 = 2;
10766 dgst_pos3 = 3;
10767 break;
10768
10769 case 13762: hash_type = HASH_TYPE_SHA256;
10770 salt_type = SALT_TYPE_EMBEDDED;
10771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10772 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10773 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10774 dgst_size = DGST_SIZE_4_8;
10775 parse_func = veracrypt_parse_hash_200000;
10776 sort_by_digest = sort_by_digest_4_8;
10777 opti_type = OPTI_TYPE_ZERO_BYTE;
10778 dgst_pos0 = 0;
10779 dgst_pos1 = 1;
10780 dgst_pos2 = 2;
10781 dgst_pos3 = 3;
10782 break;
10783
10784 case 13763: hash_type = HASH_TYPE_SHA256;
10785 salt_type = SALT_TYPE_EMBEDDED;
10786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10787 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10788 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10789 dgst_size = DGST_SIZE_4_8;
10790 parse_func = veracrypt_parse_hash_200000;
10791 sort_by_digest = sort_by_digest_4_8;
10792 opti_type = OPTI_TYPE_ZERO_BYTE;
10793 dgst_pos0 = 0;
10794 dgst_pos1 = 1;
10795 dgst_pos2 = 2;
10796 dgst_pos3 = 3;
10797 break;
10798
10799
10800 default: usage_mini_print (PROGNAME); return (-1);
10801 }
10802
10803 /**
10804 * parser
10805 */
10806
10807 data.parse_func = parse_func;
10808
10809 /**
10810 * misc stuff
10811 */
10812
10813 if (hex_salt)
10814 {
10815 if (salt_type == SALT_TYPE_INTERN)
10816 {
10817 opts_type |= OPTS_TYPE_ST_HEX;
10818 }
10819 else
10820 {
10821 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10822
10823 return (-1);
10824 }
10825 }
10826
10827 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10828 | (salt_type == SALT_TYPE_EXTERN)
10829 | (salt_type == SALT_TYPE_EMBEDDED)
10830 | (salt_type == SALT_TYPE_VIRTUAL));
10831
10832 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10833
10834 data.hash_type = hash_type;
10835 data.attack_mode = attack_mode;
10836 data.attack_kern = attack_kern;
10837 data.attack_exec = attack_exec;
10838 data.kern_type = kern_type;
10839 data.opts_type = opts_type;
10840 data.dgst_size = dgst_size;
10841 data.salt_type = salt_type;
10842 data.isSalted = isSalted;
10843 data.sort_by_digest = sort_by_digest;
10844 data.dgst_pos0 = dgst_pos0;
10845 data.dgst_pos1 = dgst_pos1;
10846 data.dgst_pos2 = dgst_pos2;
10847 data.dgst_pos3 = dgst_pos3;
10848
10849 esalt_size = 0;
10850
10851 switch (hash_mode)
10852 {
10853 case 2500: esalt_size = sizeof (wpa_t); break;
10854 case 5300: esalt_size = sizeof (ikepsk_t); break;
10855 case 5400: esalt_size = sizeof (ikepsk_t); break;
10856 case 5500: esalt_size = sizeof (netntlm_t); break;
10857 case 5600: esalt_size = sizeof (netntlm_t); break;
10858 case 6211: esalt_size = sizeof (tc_t); break;
10859 case 6212: esalt_size = sizeof (tc_t); break;
10860 case 6213: esalt_size = sizeof (tc_t); break;
10861 case 6221: esalt_size = sizeof (tc_t); break;
10862 case 6222: esalt_size = sizeof (tc_t); break;
10863 case 6223: esalt_size = sizeof (tc_t); break;
10864 case 6231: esalt_size = sizeof (tc_t); break;
10865 case 6232: esalt_size = sizeof (tc_t); break;
10866 case 6233: esalt_size = sizeof (tc_t); break;
10867 case 6241: esalt_size = sizeof (tc_t); break;
10868 case 6242: esalt_size = sizeof (tc_t); break;
10869 case 6243: esalt_size = sizeof (tc_t); break;
10870 case 6600: esalt_size = sizeof (agilekey_t); break;
10871 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10872 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10873 case 7300: esalt_size = sizeof (rakp_t); break;
10874 case 7500: esalt_size = sizeof (krb5pa_t); break;
10875 case 8200: esalt_size = sizeof (cloudkey_t); break;
10876 case 8800: esalt_size = sizeof (androidfde_t); break;
10877 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10878 case 9400: esalt_size = sizeof (office2007_t); break;
10879 case 9500: esalt_size = sizeof (office2010_t); break;
10880 case 9600: esalt_size = sizeof (office2013_t); break;
10881 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10882 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10883 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10884 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10885 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10886 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10887 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10888 case 10200: esalt_size = sizeof (cram_md5_t); break;
10889 case 10400: esalt_size = sizeof (pdf_t); break;
10890 case 10410: esalt_size = sizeof (pdf_t); break;
10891 case 10420: esalt_size = sizeof (pdf_t); break;
10892 case 10500: esalt_size = sizeof (pdf_t); break;
10893 case 10600: esalt_size = sizeof (pdf_t); break;
10894 case 10700: esalt_size = sizeof (pdf_t); break;
10895 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10896 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10897 case 11400: esalt_size = sizeof (sip_t); break;
10898 case 11600: esalt_size = sizeof (seven_zip_t); break;
10899 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10900 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10901 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10902 case 13000: esalt_size = sizeof (rar5_t); break;
10903 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10904 case 13400: esalt_size = sizeof (keepass_t); break;
10905 case 13500: esalt_size = sizeof (pstoken_t); break;
10906 case 13600: esalt_size = sizeof (zip2_t); break;
10907 case 13711: esalt_size = sizeof (tc_t); break;
10908 case 13712: esalt_size = sizeof (tc_t); break;
10909 case 13713: esalt_size = sizeof (tc_t); break;
10910 case 13721: esalt_size = sizeof (tc_t); break;
10911 case 13722: esalt_size = sizeof (tc_t); break;
10912 case 13723: esalt_size = sizeof (tc_t); break;
10913 case 13731: esalt_size = sizeof (tc_t); break;
10914 case 13732: esalt_size = sizeof (tc_t); break;
10915 case 13733: esalt_size = sizeof (tc_t); break;
10916 case 13741: esalt_size = sizeof (tc_t); break;
10917 case 13742: esalt_size = sizeof (tc_t); break;
10918 case 13743: esalt_size = sizeof (tc_t); break;
10919 case 13751: esalt_size = sizeof (tc_t); break;
10920 case 13752: esalt_size = sizeof (tc_t); break;
10921 case 13753: esalt_size = sizeof (tc_t); break;
10922 case 13761: esalt_size = sizeof (tc_t); break;
10923 case 13762: esalt_size = sizeof (tc_t); break;
10924 case 13763: esalt_size = sizeof (tc_t); break;
10925 }
10926
10927 data.esalt_size = esalt_size;
10928
10929 /**
10930 * choose dictionary parser
10931 */
10932
10933 if (hash_type == HASH_TYPE_LM)
10934 {
10935 get_next_word_func = get_next_word_lm;
10936 }
10937 else if (opts_type & OPTS_TYPE_PT_UPPER)
10938 {
10939 get_next_word_func = get_next_word_uc;
10940 }
10941 else
10942 {
10943 get_next_word_func = get_next_word_std;
10944 }
10945
10946 /**
10947 * dictstat
10948 */
10949
10950 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10951
10952 #ifdef _POSIX
10953 size_t dictstat_nmemb = 0;
10954 #endif
10955
10956 #ifdef _WIN
10957 uint dictstat_nmemb = 0;
10958 #endif
10959
10960 char dictstat[256] = { 0 };
10961
10962 FILE *dictstat_fp = NULL;
10963
10964 if (keyspace == 0)
10965 {
10966 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10967
10968 dictstat_fp = fopen (dictstat, "rb");
10969
10970 if (dictstat_fp)
10971 {
10972 #ifdef _POSIX
10973 struct stat tmpstat;
10974
10975 fstat (fileno (dictstat_fp), &tmpstat);
10976 #endif
10977
10978 #ifdef _WIN
10979 struct stat64 tmpstat;
10980
10981 _fstat64 (fileno (dictstat_fp), &tmpstat);
10982 #endif
10983
10984 if (tmpstat.st_mtime < COMPTIME)
10985 {
10986 /* with v0.15 the format changed so we have to ensure user is using a good version
10987 since there is no version-header in the dictstat file */
10988
10989 fclose (dictstat_fp);
10990
10991 unlink (dictstat);
10992 }
10993 else
10994 {
10995 while (!feof (dictstat_fp))
10996 {
10997 dictstat_t d;
10998
10999 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11000
11001 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11002
11003 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11004 {
11005 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11006
11007 return -1;
11008 }
11009 }
11010
11011 fclose (dictstat_fp);
11012 }
11013 }
11014 }
11015
11016 /**
11017 * potfile
11018 */
11019
11020 char potfile[256] = { 0 };
11021
11022 if (potfile_path == NULL)
11023 {
11024 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11025 }
11026 else
11027 {
11028 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11029 }
11030
11031 data.pot_fp = NULL;
11032
11033 FILE *out_fp = NULL;
11034 FILE *pot_fp = NULL;
11035
11036 if (show == 1 || left == 1)
11037 {
11038 pot_fp = fopen (potfile, "rb");
11039
11040 if (pot_fp == NULL)
11041 {
11042 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11043
11044 return (-1);
11045 }
11046
11047 if (outfile != NULL)
11048 {
11049 if ((out_fp = fopen (outfile, "ab")) == NULL)
11050 {
11051 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11052
11053 fclose (pot_fp);
11054
11055 return (-1);
11056 }
11057 }
11058 else
11059 {
11060 out_fp = stdout;
11061 }
11062 }
11063 else
11064 {
11065 if (potfile_disable == 0)
11066 {
11067 pot_fp = fopen (potfile, "ab");
11068
11069 if (pot_fp == NULL)
11070 {
11071 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11072
11073 return (-1);
11074 }
11075
11076 data.pot_fp = pot_fp;
11077 }
11078 }
11079
11080 pot_t *pot = NULL;
11081
11082 uint pot_cnt = 0;
11083 uint pot_avail = 0;
11084
11085 if (show == 1 || left == 1)
11086 {
11087 SUPPRESS_OUTPUT = 1;
11088
11089 pot_avail = count_lines (pot_fp);
11090
11091 rewind (pot_fp);
11092
11093 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11094
11095 uint pot_hashes_avail = 0;
11096
11097 uint line_num = 0;
11098
11099 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11100
11101 while (!feof (pot_fp))
11102 {
11103 line_num++;
11104
11105 int line_len = fgetl (pot_fp, line_buf);
11106
11107 if (line_len == 0) continue;
11108
11109 char *plain_buf = line_buf + line_len;
11110
11111 pot_t *pot_ptr = &pot[pot_cnt];
11112
11113 hash_t *hashes_buf = &pot_ptr->hash;
11114
11115 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11116 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11117
11118 if (pot_cnt == pot_hashes_avail)
11119 {
11120 uint pos = 0;
11121
11122 for (pos = 0; pos < INCR_POT; pos++)
11123 {
11124 if ((pot_cnt + pos) >= pot_avail) break;
11125
11126 pot_t *tmp_pot = &pot[pot_cnt + pos];
11127
11128 hash_t *tmp_hash = &tmp_pot->hash;
11129
11130 tmp_hash->digest = mymalloc (dgst_size);
11131
11132 if (isSalted)
11133 {
11134 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11135 }
11136
11137 if (esalt_size)
11138 {
11139 tmp_hash->esalt = mymalloc (esalt_size);
11140 }
11141
11142 pot_hashes_avail++;
11143 }
11144 }
11145
11146 int plain_len = 0;
11147
11148 int parser_status;
11149
11150 int iter = MAX_CUT_TRIES;
11151
11152 do
11153 {
11154 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11155 {
11156 if (line_buf[i] == ':')
11157 {
11158 line_len--;
11159
11160 break;
11161 }
11162 }
11163
11164 if (data.hash_mode != 2500)
11165 {
11166 parser_status = parse_func (line_buf, line_len, hashes_buf);
11167 }
11168 else
11169 {
11170 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11171
11172 if (line_len > max_salt_size)
11173 {
11174 parser_status = PARSER_GLOBAL_LENGTH;
11175 }
11176 else
11177 {
11178 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11179
11180 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11181
11182 hashes_buf->salt->salt_len = line_len;
11183
11184 parser_status = PARSER_OK;
11185 }
11186 }
11187
11188 // if NOT parsed without error, we add the ":" to the plain
11189
11190 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11191 {
11192 plain_len++;
11193 plain_buf--;
11194 }
11195
11196 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11197
11198 if (parser_status < PARSER_GLOBAL_ZERO)
11199 {
11200 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11201
11202 continue;
11203 }
11204
11205 if (plain_len >= 255) continue;
11206
11207 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11208
11209 pot_ptr->plain_len = plain_len;
11210
11211 pot_cnt++;
11212 }
11213
11214 myfree (line_buf);
11215
11216 fclose (pot_fp);
11217
11218 SUPPRESS_OUTPUT = 0;
11219
11220 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11221 }
11222
11223 /**
11224 * word len
11225 */
11226
11227 uint pw_min = PW_MIN;
11228 uint pw_max = PW_MAX;
11229
11230 switch (hash_mode)
11231 {
11232 case 125: if (pw_max > 32) pw_max = 32;
11233 break;
11234 case 400: if (pw_max > 40) pw_max = 40;
11235 break;
11236 case 500: if (pw_max > 16) pw_max = 16;
11237 break;
11238 case 1500: if (pw_max > 8) pw_max = 8;
11239 break;
11240 case 1600: if (pw_max > 16) pw_max = 16;
11241 break;
11242 case 1800: if (pw_max > 16) pw_max = 16;
11243 break;
11244 case 2100: if (pw_max > 16) pw_max = 16;
11245 break;
11246 case 2500: if (pw_min < 8) pw_min = 8;
11247 break;
11248 case 3000: if (pw_max > 7) pw_max = 7;
11249 break;
11250 case 5200: if (pw_max > 24) pw_max = 24;
11251 break;
11252 case 5800: if (pw_max > 16) pw_max = 16;
11253 break;
11254 case 6300: if (pw_max > 16) pw_max = 16;
11255 break;
11256 case 7400: if (pw_max > 16) pw_max = 16;
11257 break;
11258 case 7500: if (pw_max > 8) pw_max = 8;
11259 break;
11260 case 7900: if (pw_max > 48) pw_max = 48;
11261 break;
11262 case 8500: if (pw_max > 8) pw_max = 8;
11263 break;
11264 case 8600: if (pw_max > 16) pw_max = 16;
11265 break;
11266 case 9710: pw_min = 5;
11267 pw_max = 5;
11268 break;
11269 case 9810: pw_min = 5;
11270 pw_max = 5;
11271 break;
11272 case 10410: pw_min = 5;
11273 pw_max = 5;
11274 break;
11275 case 10300: if (pw_max < 3) pw_min = 3;
11276 if (pw_max > 40) pw_max = 40;
11277 break;
11278 case 10500: if (pw_max < 3) pw_min = 3;
11279 if (pw_max > 40) pw_max = 40;
11280 break;
11281 case 10700: if (pw_max > 16) pw_max = 16;
11282 break;
11283 case 11300: if (pw_max > 40) pw_max = 40;
11284 break;
11285 case 11600: if (pw_max > 32) pw_max = 32;
11286 break;
11287 case 12500: if (pw_max > 20) pw_max = 20;
11288 break;
11289 case 12800: if (pw_max > 24) pw_max = 24;
11290 break;
11291 }
11292
11293 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11294 {
11295 switch (attack_kern)
11296 {
11297 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11298 break;
11299 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11300 break;
11301 }
11302 }
11303
11304 /**
11305 * charsets : keep them together for more easy maintainnce
11306 */
11307
11308 cs_t mp_sys[6] = { { { 0 }, 0 } };
11309 cs_t mp_usr[4] = { { { 0 }, 0 } };
11310
11311 mp_setup_sys (mp_sys);
11312
11313 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11314 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11315 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11316 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11317
11318 /**
11319 * load hashes, part I: find input mode, count hashes
11320 */
11321
11322 uint hashlist_mode = 0;
11323 uint hashlist_format = HLFMT_HASHCAT;
11324
11325 uint hashes_avail = 0;
11326
11327 if (benchmark == 0)
11328 {
11329 struct stat f;
11330
11331 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11332
11333 if ((hash_mode == 2500) ||
11334 (hash_mode == 5200) ||
11335 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11336 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11337 (hash_mode == 9000))
11338 {
11339 hashlist_mode = HL_MODE_ARG;
11340
11341 char *hashfile = myargv[optind];
11342
11343 data.hashfile = hashfile;
11344
11345 logfile_top_var_string ("target", hashfile);
11346 }
11347
11348 if (hashlist_mode == HL_MODE_ARG)
11349 {
11350 if (hash_mode == 2500)
11351 {
11352 struct stat st;
11353
11354 if (stat (data.hashfile, &st) == -1)
11355 {
11356 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11357
11358 return (-1);
11359 }
11360
11361 hashes_avail = st.st_size / sizeof (hccap_t);
11362 }
11363 else
11364 {
11365 hashes_avail = 1;
11366 }
11367 }
11368 else if (hashlist_mode == HL_MODE_FILE)
11369 {
11370 char *hashfile = myargv[optind];
11371
11372 data.hashfile = hashfile;
11373
11374 logfile_top_var_string ("target", hashfile);
11375
11376 FILE *fp = NULL;
11377
11378 if ((fp = fopen (hashfile, "rb")) == NULL)
11379 {
11380 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11381
11382 return (-1);
11383 }
11384
11385 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11386
11387 hashes_avail = count_lines (fp);
11388
11389 rewind (fp);
11390
11391 if (hashes_avail == 0)
11392 {
11393 log_error ("ERROR: hashfile is empty or corrupt");
11394
11395 fclose (fp);
11396
11397 return (-1);
11398 }
11399
11400 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11401
11402 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11403 {
11404 log_error ("ERROR: remove not supported in native hashfile-format mode");
11405
11406 fclose (fp);
11407
11408 return (-1);
11409 }
11410
11411 fclose (fp);
11412 }
11413 }
11414 else
11415 {
11416 hashlist_mode = HL_MODE_ARG;
11417
11418 hashes_avail = 1;
11419 }
11420
11421 if (hash_mode == 3000) hashes_avail *= 2;
11422
11423 data.hashlist_mode = hashlist_mode;
11424 data.hashlist_format = hashlist_format;
11425
11426 logfile_top_uint (hashlist_mode);
11427 logfile_top_uint (hashlist_format);
11428
11429 /**
11430 * load hashes, part II: allocate required memory, set pointers
11431 */
11432
11433 hash_t *hashes_buf = NULL;
11434 void *digests_buf = NULL;
11435 salt_t *salts_buf = NULL;
11436 void *esalts_buf = NULL;
11437
11438 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11439
11440 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11441
11442 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11443 {
11444 u32 hash_pos;
11445
11446 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11447 {
11448 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11449
11450 hashes_buf[hash_pos].hash_info = hash_info;
11451
11452 if (username && (remove || show || left))
11453 {
11454 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11455 }
11456
11457 if (benchmark)
11458 {
11459 hash_info->orighash = (char *) mymalloc (256);
11460 }
11461 }
11462 }
11463
11464 if (isSalted)
11465 {
11466 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11467
11468 if (esalt_size)
11469 {
11470 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11471 }
11472 }
11473 else
11474 {
11475 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11476 }
11477
11478 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11479 {
11480 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11481
11482 if (isSalted)
11483 {
11484 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11485
11486 if (esalt_size)
11487 {
11488 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11489 }
11490 }
11491 else
11492 {
11493 hashes_buf[hash_pos].salt = &salts_buf[0];
11494 }
11495 }
11496
11497 /**
11498 * load hashes, part III: parse hashes or generate them if benchmark
11499 */
11500
11501 uint hashes_cnt = 0;
11502
11503 if (benchmark == 0)
11504 {
11505 if (keyspace == 1)
11506 {
11507 // useless to read hash file for keyspace, cheat a little bit w/ optind
11508 }
11509 else if (hashes_avail == 0)
11510 {
11511 }
11512 else if (hashlist_mode == HL_MODE_ARG)
11513 {
11514 char *input_buf = myargv[optind];
11515
11516 uint input_len = strlen (input_buf);
11517
11518 logfile_top_var_string ("target", input_buf);
11519
11520 char *hash_buf = NULL;
11521 int hash_len = 0;
11522
11523 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11524
11525 bool hash_fmt_error = 0;
11526
11527 if (hash_len < 1) hash_fmt_error = 1;
11528 if (hash_buf == NULL) hash_fmt_error = 1;
11529
11530 if (hash_fmt_error)
11531 {
11532 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11533 }
11534 else
11535 {
11536 if (opts_type & OPTS_TYPE_HASH_COPY)
11537 {
11538 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11539
11540 hash_info_tmp->orighash = mystrdup (hash_buf);
11541 }
11542
11543 if (isSalted)
11544 {
11545 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11546 }
11547
11548 int parser_status = PARSER_OK;
11549
11550 if (hash_mode == 2500)
11551 {
11552 if (hash_len == 0)
11553 {
11554 log_error ("ERROR: hccap file not specified");
11555
11556 return (-1);
11557 }
11558
11559 hashlist_mode = HL_MODE_FILE;
11560
11561 data.hashlist_mode = hashlist_mode;
11562
11563 FILE *fp = fopen (hash_buf, "rb");
11564
11565 if (fp == NULL)
11566 {
11567 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11568
11569 return (-1);
11570 }
11571
11572 if (hashes_avail < 1)
11573 {
11574 log_error ("ERROR: hccap file is empty or corrupt");
11575
11576 fclose (fp);
11577
11578 return (-1);
11579 }
11580
11581 uint hccap_size = sizeof (hccap_t);
11582
11583 char *in = (char *) mymalloc (hccap_size);
11584
11585 while (!feof (fp))
11586 {
11587 int n = fread (in, hccap_size, 1, fp);
11588
11589 if (n != 1)
11590 {
11591 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11592
11593 break;
11594 }
11595
11596 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11597
11598 if (parser_status != PARSER_OK)
11599 {
11600 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11601
11602 continue;
11603 }
11604
11605 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11606
11607 if ((show == 1) || (left == 1))
11608 {
11609 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11610
11611 char *salt_ptr = (char *) tmp_salt->salt_buf;
11612
11613 int cur_pos = tmp_salt->salt_len;
11614 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11615
11616 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11617
11618 // do the appending task
11619
11620 snprintf (salt_ptr + cur_pos,
11621 rem_len,
11622 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11623 wpa->orig_mac1[0],
11624 wpa->orig_mac1[1],
11625 wpa->orig_mac1[2],
11626 wpa->orig_mac1[3],
11627 wpa->orig_mac1[4],
11628 wpa->orig_mac1[5],
11629 wpa->orig_mac2[0],
11630 wpa->orig_mac2[1],
11631 wpa->orig_mac2[2],
11632 wpa->orig_mac2[3],
11633 wpa->orig_mac2[4],
11634 wpa->orig_mac2[5]);
11635
11636 // memset () the remaining part of the salt
11637
11638 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11639 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11640
11641 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11642
11643 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11644 }
11645
11646 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);
11647 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);
11648
11649 hashes_cnt++;
11650 }
11651
11652 fclose (fp);
11653
11654 myfree (in);
11655 }
11656 else if (hash_mode == 3000)
11657 {
11658 if (hash_len == 32)
11659 {
11660 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11661
11662 hash_t *lm_hash_left = NULL;
11663
11664 if (parser_status == PARSER_OK)
11665 {
11666 lm_hash_left = &hashes_buf[hashes_cnt];
11667
11668 hashes_cnt++;
11669 }
11670 else
11671 {
11672 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11673 }
11674
11675 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11676
11677 hash_t *lm_hash_right = NULL;
11678
11679 if (parser_status == PARSER_OK)
11680 {
11681 lm_hash_right = &hashes_buf[hashes_cnt];
11682
11683 hashes_cnt++;
11684 }
11685 else
11686 {
11687 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11688 }
11689
11690 // show / left
11691
11692 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11693 {
11694 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);
11695 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);
11696 }
11697 }
11698 else
11699 {
11700 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11701
11702 if (parser_status == PARSER_OK)
11703 {
11704 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11705 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11706 }
11707
11708 if (parser_status == PARSER_OK)
11709 {
11710 hashes_cnt++;
11711 }
11712 else
11713 {
11714 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11715 }
11716 }
11717 }
11718 else
11719 {
11720 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11721
11722 if (parser_status == PARSER_OK)
11723 {
11724 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11725 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11726 }
11727
11728 if (parser_status == PARSER_OK)
11729 {
11730 hashes_cnt++;
11731 }
11732 else
11733 {
11734 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11735 }
11736 }
11737 }
11738 }
11739 else if (hashlist_mode == HL_MODE_FILE)
11740 {
11741 char *hashfile = data.hashfile;
11742
11743 FILE *fp;
11744
11745 if ((fp = fopen (hashfile, "rb")) == NULL)
11746 {
11747 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11748
11749 return (-1);
11750 }
11751
11752 uint line_num = 0;
11753
11754 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11755
11756 while (!feof (fp))
11757 {
11758 line_num++;
11759
11760 int line_len = fgetl (fp, line_buf);
11761
11762 if (line_len == 0) continue;
11763
11764 char *hash_buf = NULL;
11765 int hash_len = 0;
11766
11767 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11768
11769 bool hash_fmt_error = 0;
11770
11771 if (hash_len < 1) hash_fmt_error = 1;
11772 if (hash_buf == NULL) hash_fmt_error = 1;
11773
11774 if (hash_fmt_error)
11775 {
11776 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11777
11778 continue;
11779 }
11780
11781 if (username)
11782 {
11783 char *user_buf = NULL;
11784 int user_len = 0;
11785
11786 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11787
11788 if (remove || show)
11789 {
11790 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11791
11792 *user = (user_t *) mymalloc (sizeof (user_t));
11793
11794 user_t *user_ptr = *user;
11795
11796 if (user_buf != NULL)
11797 {
11798 user_ptr->user_name = mystrdup (user_buf);
11799 }
11800 else
11801 {
11802 user_ptr->user_name = mystrdup ("");
11803 }
11804
11805 user_ptr->user_len = user_len;
11806 }
11807 }
11808
11809 if (opts_type & OPTS_TYPE_HASH_COPY)
11810 {
11811 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11812
11813 hash_info_tmp->orighash = mystrdup (hash_buf);
11814 }
11815
11816 if (isSalted)
11817 {
11818 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11819 }
11820
11821 if (hash_mode == 3000)
11822 {
11823 if (hash_len == 32)
11824 {
11825 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11826
11827 if (parser_status < PARSER_GLOBAL_ZERO)
11828 {
11829 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11830
11831 continue;
11832 }
11833
11834 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11835
11836 hashes_cnt++;
11837
11838 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11839
11840 if (parser_status < PARSER_GLOBAL_ZERO)
11841 {
11842 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11843
11844 continue;
11845 }
11846
11847 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11848
11849 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);
11850
11851 hashes_cnt++;
11852
11853 // show / left
11854
11855 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);
11856 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);
11857 }
11858 else
11859 {
11860 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11861
11862 if (parser_status < PARSER_GLOBAL_ZERO)
11863 {
11864 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11865
11866 continue;
11867 }
11868
11869 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);
11870
11871 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11872 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11873
11874 hashes_cnt++;
11875 }
11876 }
11877 else
11878 {
11879 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11880
11881 if (parser_status < PARSER_GLOBAL_ZERO)
11882 {
11883 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11884
11885 continue;
11886 }
11887
11888 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);
11889
11890 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11891 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11892
11893 hashes_cnt++;
11894 }
11895 }
11896
11897 myfree (line_buf);
11898
11899 fclose (fp);
11900
11901 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11902
11903 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11904 }
11905 }
11906 else
11907 {
11908 if (isSalted)
11909 {
11910 hashes_buf[0].salt->salt_len = 8;
11911
11912 // special salt handling
11913
11914 switch (hash_mode)
11915 {
11916 case 1500: hashes_buf[0].salt->salt_len = 2;
11917 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11918 break;
11919 case 1731: hashes_buf[0].salt->salt_len = 4;
11920 break;
11921 case 2410: hashes_buf[0].salt->salt_len = 4;
11922 break;
11923 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11924 break;
11925 case 3100: hashes_buf[0].salt->salt_len = 1;
11926 break;
11927 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11928 break;
11929 case 5800: hashes_buf[0].salt->salt_len = 16;
11930 break;
11931 case 6800: hashes_buf[0].salt->salt_len = 32;
11932 break;
11933 case 8400: hashes_buf[0].salt->salt_len = 40;
11934 break;
11935 case 8800: hashes_buf[0].salt->salt_len = 16;
11936 break;
11937 case 8900: hashes_buf[0].salt->salt_len = 16;
11938 hashes_buf[0].salt->scrypt_N = 1024;
11939 hashes_buf[0].salt->scrypt_r = 1;
11940 hashes_buf[0].salt->scrypt_p = 1;
11941 break;
11942 case 9100: hashes_buf[0].salt->salt_len = 16;
11943 break;
11944 case 9300: hashes_buf[0].salt->salt_len = 14;
11945 hashes_buf[0].salt->scrypt_N = 16384;
11946 hashes_buf[0].salt->scrypt_r = 1;
11947 hashes_buf[0].salt->scrypt_p = 1;
11948 break;
11949 case 9400: hashes_buf[0].salt->salt_len = 16;
11950 break;
11951 case 9500: hashes_buf[0].salt->salt_len = 16;
11952 break;
11953 case 9600: hashes_buf[0].salt->salt_len = 16;
11954 break;
11955 case 9700: hashes_buf[0].salt->salt_len = 16;
11956 break;
11957 case 9710: hashes_buf[0].salt->salt_len = 16;
11958 break;
11959 case 9720: hashes_buf[0].salt->salt_len = 16;
11960 break;
11961 case 9800: hashes_buf[0].salt->salt_len = 16;
11962 break;
11963 case 9810: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9820: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 10300: hashes_buf[0].salt->salt_len = 12;
11968 break;
11969 case 11500: hashes_buf[0].salt->salt_len = 4;
11970 break;
11971 case 11600: hashes_buf[0].salt->salt_len = 4;
11972 break;
11973 case 12400: hashes_buf[0].salt->salt_len = 4;
11974 break;
11975 case 12500: hashes_buf[0].salt->salt_len = 8;
11976 break;
11977 case 12600: hashes_buf[0].salt->salt_len = 64;
11978 break;
11979 }
11980
11981 // special esalt handling
11982
11983 switch (hash_mode)
11984 {
11985 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11986 break;
11987 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11988 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11989 break;
11990 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11991 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11992 break;
11993 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11994 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11995 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11996 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11997 break;
11998 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12000 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12001 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12002 break;
12003 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12004 break;
12005 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12006 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12007 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12008 break;
12009 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12010 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12011 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12012 break;
12013 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12014 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12015 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12016 break;
12017 case 10500: ((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 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12022 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12023 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12024 break;
12025 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12026 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12027 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12028 break;
12029 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12030 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12031 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12032 break;
12033 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12034 break;
12035 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12036 break;
12037 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12038 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12039 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12040 break;
12041 }
12042 }
12043
12044 // set hashfile
12045
12046 switch (hash_mode)
12047 {
12048 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12049 break;
12050 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12051 break;
12052 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12053 break;
12054 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12055 break;
12056 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12057 break;
12058 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12059 break;
12060 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12061 break;
12062 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12063 break;
12064 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12065 break;
12066 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12067 break;
12068 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12079 break;
12080 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12081 break;
12082 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12083 break;
12084 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12085 break;
12086 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12087 break;
12088 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12089 break;
12090 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12091 break;
12092 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12093 break;
12094 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12095 break;
12096 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12097 break;
12098 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 }
12121
12122 // set default iterations
12123
12124 switch (hash_mode)
12125 {
12126 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12127 break;
12128 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12129 break;
12130 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12131 break;
12132 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12133 break;
12134 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12135 break;
12136 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12137 break;
12138 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12139 break;
12140 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12141 break;
12142 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12143 break;
12144 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12145 break;
12146 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12147 break;
12148 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12149 break;
12150 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12151 break;
12152 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12153 break;
12154 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12155 break;
12156 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12157 break;
12158 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12159 break;
12160 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12161 break;
12162 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12163 break;
12164 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12165 break;
12166 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12171 break;
12172 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12173 break;
12174 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12175 break;
12176 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12177 break;
12178 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12179 break;
12180 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12181 break;
12182 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12183 break;
12184 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12185 break;
12186 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12187 break;
12188 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12189 break;
12190 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12191 break;
12192 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12193 break;
12194 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12195 break;
12196 case 8900: hashes_buf[0].salt->salt_iter = 1;
12197 break;
12198 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12199 break;
12200 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12201 break;
12202 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12203 break;
12204 case 9300: hashes_buf[0].salt->salt_iter = 1;
12205 break;
12206 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12207 break;
12208 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12209 break;
12210 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12211 break;
12212 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12213 break;
12214 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12215 break;
12216 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12217 break;
12218 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12219 break;
12220 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12221 break;
12222 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12223 break;
12224 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12225 break;
12226 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12227 break;
12228 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12229 break;
12230 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12231 break;
12232 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12233 break;
12234 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12235 break;
12236 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12237 break;
12238 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12239 break;
12240 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12241 break;
12242 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12243 break;
12244 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12245 break;
12246 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12247 break;
12248 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12249 break;
12250 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12251 break;
12252 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12253 break;
12254 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12255 break;
12256 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12257 break;
12258 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12259 break;
12260 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12261 break;
12262 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12263 break;
12264 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12265 break;
12266 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12267 break;
12268 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12269 break;
12270 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12271 break;
12272 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12273 break;
12274 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12275 break;
12276 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12277 break;
12278 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12281 break;
12282 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12283 break;
12284 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12285 break;
12286 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12287 break;
12288 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12289 break;
12290 }
12291
12292 hashes_cnt = 1;
12293 }
12294
12295 if (show == 1 || left == 1)
12296 {
12297 for (uint i = 0; i < pot_cnt; i++)
12298 {
12299 pot_t *pot_ptr = &pot[i];
12300
12301 hash_t *hashes_buf = &pot_ptr->hash;
12302
12303 local_free (hashes_buf->digest);
12304
12305 if (isSalted)
12306 {
12307 local_free (hashes_buf->salt);
12308 }
12309 }
12310
12311 local_free (pot);
12312
12313 if (data.quiet == 0) log_info_nn ("");
12314
12315 return (0);
12316 }
12317
12318 if (keyspace == 0)
12319 {
12320 if (hashes_cnt == 0)
12321 {
12322 log_error ("ERROR: No hashes loaded");
12323
12324 return (-1);
12325 }
12326 }
12327
12328 /**
12329 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12330 */
12331
12332 if (data.outfile != NULL)
12333 {
12334 if (data.hashfile != NULL)
12335 {
12336 #ifdef _POSIX
12337 struct stat tmpstat_outfile;
12338 struct stat tmpstat_hashfile;
12339 #endif
12340
12341 #ifdef _WIN
12342 struct stat64 tmpstat_outfile;
12343 struct stat64 tmpstat_hashfile;
12344 #endif
12345
12346 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12347
12348 if (tmp_outfile_fp)
12349 {
12350 #ifdef _POSIX
12351 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12352 #endif
12353
12354 #ifdef _WIN
12355 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12356 #endif
12357
12358 fclose (tmp_outfile_fp);
12359 }
12360
12361 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12362
12363 if (tmp_hashfile_fp)
12364 {
12365 #ifdef _POSIX
12366 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12367 #endif
12368
12369 #ifdef _WIN
12370 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12371 #endif
12372
12373 fclose (tmp_hashfile_fp);
12374 }
12375
12376 if (tmp_outfile_fp && tmp_outfile_fp)
12377 {
12378 tmpstat_outfile.st_mode = 0;
12379 tmpstat_outfile.st_nlink = 0;
12380 tmpstat_outfile.st_uid = 0;
12381 tmpstat_outfile.st_gid = 0;
12382 tmpstat_outfile.st_rdev = 0;
12383 tmpstat_outfile.st_atime = 0;
12384
12385 tmpstat_hashfile.st_mode = 0;
12386 tmpstat_hashfile.st_nlink = 0;
12387 tmpstat_hashfile.st_uid = 0;
12388 tmpstat_hashfile.st_gid = 0;
12389 tmpstat_hashfile.st_rdev = 0;
12390 tmpstat_hashfile.st_atime = 0;
12391
12392 #ifdef _POSIX
12393 tmpstat_outfile.st_blksize = 0;
12394 tmpstat_outfile.st_blocks = 0;
12395
12396 tmpstat_hashfile.st_blksize = 0;
12397 tmpstat_hashfile.st_blocks = 0;
12398 #endif
12399
12400 #ifdef _POSIX
12401 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12402 {
12403 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12404
12405 return (-1);
12406 }
12407 #endif
12408
12409 #ifdef _WIN
12410 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12411 {
12412 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12413
12414 return (-1);
12415 }
12416 #endif
12417 }
12418 }
12419 }
12420
12421 /**
12422 * Remove duplicates
12423 */
12424
12425 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12426
12427 if (isSalted)
12428 {
12429 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12430 }
12431 else
12432 {
12433 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12434 }
12435
12436 uint hashes_cnt_orig = hashes_cnt;
12437
12438 hashes_cnt = 1;
12439
12440 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12441 {
12442 if (isSalted)
12443 {
12444 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12445 {
12446 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12447 }
12448 }
12449 else
12450 {
12451 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12452 }
12453
12454 if (hashes_pos > hashes_cnt)
12455 {
12456 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12457 }
12458
12459 hashes_cnt++;
12460 }
12461
12462 /**
12463 * Potfile removes
12464 */
12465
12466 uint potfile_remove_cracks = 0;
12467
12468 if (potfile_disable == 0)
12469 {
12470 hash_t hash_buf;
12471
12472 hash_buf.digest = mymalloc (dgst_size);
12473 hash_buf.salt = NULL;
12474 hash_buf.esalt = NULL;
12475 hash_buf.hash_info = NULL;
12476 hash_buf.cracked = 0;
12477
12478 if (isSalted)
12479 {
12480 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12481 }
12482
12483 if (esalt_size)
12484 {
12485 hash_buf.esalt = mymalloc (esalt_size);
12486 }
12487
12488 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12489
12490 // no solution for these special hash types (for instane because they use hashfile in output etc)
12491 if ((hash_mode != 5200) &&
12492 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12493 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12494 (hash_mode != 9000))
12495 {
12496 FILE *fp = fopen (potfile, "rb");
12497
12498 if (fp != NULL)
12499 {
12500 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12501
12502 // to be safe work with a copy (because of line_len loop, i etc)
12503 // moved up here because it's easier to handle continue case
12504 // it's just 64kb
12505
12506 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12507
12508 while (!feof (fp))
12509 {
12510 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12511
12512 if (ptr == NULL) break;
12513
12514 int line_len = strlen (line_buf);
12515
12516 if (line_len == 0) continue;
12517
12518 int iter = MAX_CUT_TRIES;
12519
12520 for (int i = line_len - 1; i && iter; i--, line_len--)
12521 {
12522 if (line_buf[i] != ':') continue;
12523
12524 if (isSalted)
12525 {
12526 memset (hash_buf.salt, 0, sizeof (salt_t));
12527 }
12528
12529 hash_t *found = NULL;
12530
12531 if (hash_mode == 6800)
12532 {
12533 if (i < 64) // 64 = 16 * uint in salt_buf[]
12534 {
12535 // manipulate salt_buf
12536 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12537
12538 hash_buf.salt->salt_len = i;
12539
12540 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12541 }
12542 }
12543 else if (hash_mode == 2500)
12544 {
12545 if (i < 64) // 64 = 16 * uint in salt_buf[]
12546 {
12547 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12548 // manipulate salt_buf
12549
12550 memcpy (line_buf_cpy, line_buf, i);
12551
12552 char *mac2_pos = strrchr (line_buf_cpy, ':');
12553
12554 if (mac2_pos == NULL) continue;
12555
12556 mac2_pos[0] = 0;
12557 mac2_pos++;
12558
12559 if (strlen (mac2_pos) != 12) continue;
12560
12561 char *mac1_pos = strrchr (line_buf_cpy, ':');
12562
12563 if (mac1_pos == NULL) continue;
12564
12565 mac1_pos[0] = 0;
12566 mac1_pos++;
12567
12568 if (strlen (mac1_pos) != 12) continue;
12569
12570 uint essid_length = mac1_pos - line_buf_cpy - 1;
12571
12572 // here we need the ESSID
12573 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12574
12575 hash_buf.salt->salt_len = essid_length;
12576
12577 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12578
12579 if (found)
12580 {
12581 wpa_t *wpa = (wpa_t *) found->esalt;
12582
12583 // compare hex string(s) vs binary MAC address(es)
12584
12585 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12586 {
12587 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12588 {
12589 found = NULL;
12590
12591 break;
12592 }
12593 }
12594
12595 // early skip ;)
12596 if (!found) continue;
12597
12598 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12599 {
12600 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12601 {
12602 found = NULL;
12603
12604 break;
12605 }
12606 }
12607 }
12608 }
12609 }
12610 else
12611 {
12612 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12613
12614 if (parser_status == PARSER_OK)
12615 {
12616 if (isSalted)
12617 {
12618 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12619 }
12620 else
12621 {
12622 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12623 }
12624 }
12625 }
12626
12627 if (found == NULL) continue;
12628
12629 if (!found->cracked) potfile_remove_cracks++;
12630
12631 found->cracked = 1;
12632
12633 if (found) break;
12634
12635 iter--;
12636 }
12637 }
12638
12639 myfree (line_buf_cpy);
12640
12641 myfree (line_buf);
12642
12643 fclose (fp);
12644 }
12645 }
12646
12647 if (esalt_size)
12648 {
12649 local_free (hash_buf.esalt);
12650 }
12651
12652 if (isSalted)
12653 {
12654 local_free (hash_buf.salt);
12655 }
12656
12657 local_free (hash_buf.digest);
12658 }
12659
12660 /**
12661 * Now generate all the buffers required for later
12662 */
12663
12664 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12665
12666 salt_t *salts_buf_new = NULL;
12667 void *esalts_buf_new = NULL;
12668
12669 if (isSalted)
12670 {
12671 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12672
12673 if (esalt_size)
12674 {
12675 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12676 }
12677 }
12678 else
12679 {
12680 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12681 }
12682
12683 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12684
12685 uint digests_cnt = hashes_cnt;
12686 uint digests_done = 0;
12687
12688 size_t size_digests = digests_cnt * dgst_size;
12689 size_t size_shown = digests_cnt * sizeof (uint);
12690
12691 uint *digests_shown = (uint *) mymalloc (size_shown);
12692 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12693
12694 uint salts_cnt = 0;
12695 uint salts_done = 0;
12696
12697 hashinfo_t **hash_info = NULL;
12698
12699 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12700 {
12701 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12702
12703 if (username && (remove || show))
12704 {
12705 uint user_pos;
12706
12707 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12708 {
12709 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12710
12711 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12712 }
12713 }
12714 }
12715
12716 uint *salts_shown = (uint *) mymalloc (size_shown);
12717
12718 salt_t *salt_buf;
12719
12720 {
12721 // copied from inner loop
12722
12723 salt_buf = &salts_buf_new[salts_cnt];
12724
12725 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12726
12727 if (esalt_size)
12728 {
12729 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12730 }
12731
12732 salt_buf->digests_cnt = 0;
12733 salt_buf->digests_done = 0;
12734 salt_buf->digests_offset = 0;
12735
12736 salts_cnt++;
12737 }
12738
12739 if (hashes_buf[0].cracked == 1)
12740 {
12741 digests_shown[0] = 1;
12742
12743 digests_done++;
12744
12745 salt_buf->digests_done++;
12746 }
12747
12748 salt_buf->digests_cnt++;
12749
12750 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12751
12752 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12753 {
12754 hash_info[0] = hashes_buf[0].hash_info;
12755 }
12756
12757 // copy from inner loop
12758
12759 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12760 {
12761 if (isSalted)
12762 {
12763 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12764 {
12765 salt_buf = &salts_buf_new[salts_cnt];
12766
12767 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12768
12769 if (esalt_size)
12770 {
12771 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12772 }
12773
12774 salt_buf->digests_cnt = 0;
12775 salt_buf->digests_done = 0;
12776 salt_buf->digests_offset = hashes_pos;
12777
12778 salts_cnt++;
12779 }
12780 }
12781
12782 if (hashes_buf[hashes_pos].cracked == 1)
12783 {
12784 digests_shown[hashes_pos] = 1;
12785
12786 digests_done++;
12787
12788 salt_buf->digests_done++;
12789 }
12790
12791 salt_buf->digests_cnt++;
12792
12793 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12794
12795 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12796 {
12797 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12798 }
12799 }
12800
12801 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12802 {
12803 salt_t *salt_buf = &salts_buf_new[salt_pos];
12804
12805 if (salt_buf->digests_done == salt_buf->digests_cnt)
12806 {
12807 salts_shown[salt_pos] = 1;
12808
12809 salts_done++;
12810 }
12811
12812 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12813 }
12814
12815 local_free (digests_buf);
12816 local_free (salts_buf);
12817 local_free (esalts_buf);
12818
12819 digests_buf = digests_buf_new;
12820 salts_buf = salts_buf_new;
12821 esalts_buf = esalts_buf_new;
12822
12823 local_free (hashes_buf);
12824
12825 /**
12826 * special modification not set from parser
12827 */
12828
12829 switch (hash_mode)
12830 {
12831 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12832 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12833 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12834 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12835 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12836 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12837 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12838 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12839 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12840 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12841 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12842 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12843 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 }
12862
12863 if (truecrypt_keyfiles)
12864 {
12865 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12866
12867 char *keyfiles = strdup (truecrypt_keyfiles);
12868
12869 char *keyfile = strtok (keyfiles, ",");
12870
12871 do
12872 {
12873 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12874
12875 } while ((keyfile = strtok (NULL, ",")) != NULL);
12876
12877 free (keyfiles);
12878 }
12879
12880 if (veracrypt_keyfiles)
12881 {
12882 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12883
12884 char *keyfiles = strdup (veracrypt_keyfiles);
12885
12886 char *keyfile = strtok (keyfiles, ",");
12887
12888 do
12889 {
12890 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12891
12892 } while ((keyfile = strtok (NULL, ",")) != NULL);
12893
12894 free (keyfiles);
12895 }
12896
12897 data.digests_cnt = digests_cnt;
12898 data.digests_done = digests_done;
12899 data.digests_buf = digests_buf;
12900 data.digests_shown = digests_shown;
12901 data.digests_shown_tmp = digests_shown_tmp;
12902
12903 data.salts_cnt = salts_cnt;
12904 data.salts_done = salts_done;
12905 data.salts_buf = salts_buf;
12906 data.salts_shown = salts_shown;
12907
12908 data.esalts_buf = esalts_buf;
12909 data.hash_info = hash_info;
12910
12911 /**
12912 * Automatic Optimizers
12913 */
12914
12915 if (salts_cnt == 1)
12916 opti_type |= OPTI_TYPE_SINGLE_SALT;
12917
12918 if (digests_cnt == 1)
12919 opti_type |= OPTI_TYPE_SINGLE_HASH;
12920
12921 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12922 opti_type |= OPTI_TYPE_NOT_ITERATED;
12923
12924 if (attack_mode == ATTACK_MODE_BF)
12925 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12926
12927 data.opti_type = opti_type;
12928
12929 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12930 {
12931 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12932 {
12933 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12934 {
12935 if (opts_type & OPTS_TYPE_ST_ADD80)
12936 {
12937 opts_type &= ~OPTS_TYPE_ST_ADD80;
12938 opts_type |= OPTS_TYPE_PT_ADD80;
12939 }
12940
12941 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12942 {
12943 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12944 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12945 }
12946
12947 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12948 {
12949 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12950 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12951 }
12952 }
12953 }
12954 }
12955
12956 /**
12957 * Some algorithm, like descrypt, can benefit from JIT compilation
12958 */
12959
12960 int force_jit_compilation = -1;
12961
12962 if (hash_mode == 8900)
12963 {
12964 force_jit_compilation = 8900;
12965 }
12966 else if (hash_mode == 9300)
12967 {
12968 force_jit_compilation = 8900;
12969 }
12970 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12971 {
12972 force_jit_compilation = 1500;
12973 }
12974
12975 /**
12976 * generate bitmap tables
12977 */
12978
12979 const uint bitmap_shift1 = 5;
12980 const uint bitmap_shift2 = 13;
12981
12982 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12983
12984 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12985 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12986 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12987 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12988 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12989 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992
12993 uint bitmap_bits;
12994 uint bitmap_nums;
12995 uint bitmap_mask;
12996 uint bitmap_size;
12997
12998 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12999 {
13000 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13001
13002 bitmap_nums = 1 << bitmap_bits;
13003
13004 bitmap_mask = bitmap_nums - 1;
13005
13006 bitmap_size = bitmap_nums * sizeof (uint);
13007
13008 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13009
13010 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;
13011 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;
13012
13013 break;
13014 }
13015
13016 bitmap_nums = 1 << bitmap_bits;
13017
13018 bitmap_mask = bitmap_nums - 1;
13019
13020 bitmap_size = bitmap_nums * sizeof (uint);
13021
13022 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);
13023 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);
13024
13025 /**
13026 * prepare quick rule
13027 */
13028
13029 data.rule_buf_l = rule_buf_l;
13030 data.rule_buf_r = rule_buf_r;
13031
13032 int rule_len_l = (int) strlen (rule_buf_l);
13033 int rule_len_r = (int) strlen (rule_buf_r);
13034
13035 data.rule_len_l = rule_len_l;
13036 data.rule_len_r = rule_len_r;
13037
13038 /**
13039 * load rules
13040 */
13041
13042 uint *all_kernel_rules_cnt = NULL;
13043
13044 kernel_rule_t **all_kernel_rules_buf = NULL;
13045
13046 if (rp_files_cnt)
13047 {
13048 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13049
13050 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13051 }
13052
13053 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13054
13055 int rule_len = 0;
13056
13057 for (uint i = 0; i < rp_files_cnt; i++)
13058 {
13059 uint kernel_rules_avail = 0;
13060
13061 uint kernel_rules_cnt = 0;
13062
13063 kernel_rule_t *kernel_rules_buf = NULL;
13064
13065 char *rp_file = rp_files[i];
13066
13067 char in[BLOCK_SIZE] = { 0 };
13068 char out[BLOCK_SIZE] = { 0 };
13069
13070 FILE *fp = NULL;
13071
13072 uint rule_line = 0;
13073
13074 if ((fp = fopen (rp_file, "rb")) == NULL)
13075 {
13076 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13077
13078 return (-1);
13079 }
13080
13081 while (!feof (fp))
13082 {
13083 memset (rule_buf, 0, HCBUFSIZ);
13084
13085 rule_len = fgetl (fp, rule_buf);
13086
13087 rule_line++;
13088
13089 if (rule_len == 0) continue;
13090
13091 if (rule_buf[0] == '#') continue;
13092
13093 if (kernel_rules_avail == kernel_rules_cnt)
13094 {
13095 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13096
13097 kernel_rules_avail += INCR_RULES;
13098 }
13099
13100 memset (in, 0, BLOCK_SIZE);
13101 memset (out, 0, BLOCK_SIZE);
13102
13103 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13104
13105 if (result == -1)
13106 {
13107 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13108
13109 continue;
13110 }
13111
13112 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13113 {
13114 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13115
13116 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13117
13118 continue;
13119 }
13120
13121 /* its so slow
13122 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13123 {
13124 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13125
13126 continue;
13127 }
13128 */
13129
13130 kernel_rules_cnt++;
13131 }
13132
13133 fclose (fp);
13134
13135 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13136
13137 all_kernel_rules_buf[i] = kernel_rules_buf;
13138 }
13139
13140 /**
13141 * merge rules or automatic rule generator
13142 */
13143
13144 uint kernel_rules_cnt = 0;
13145
13146 kernel_rule_t *kernel_rules_buf = NULL;
13147
13148 if (attack_mode == ATTACK_MODE_STRAIGHT)
13149 {
13150 if (rp_files_cnt)
13151 {
13152 kernel_rules_cnt = 1;
13153
13154 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13155
13156 repeats[0] = kernel_rules_cnt;
13157
13158 for (uint i = 0; i < rp_files_cnt; i++)
13159 {
13160 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13161
13162 repeats[i + 1] = kernel_rules_cnt;
13163 }
13164
13165 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13166
13167 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13168
13169 for (uint i = 0; i < kernel_rules_cnt; i++)
13170 {
13171 uint out_pos = 0;
13172
13173 kernel_rule_t *out = &kernel_rules_buf[i];
13174
13175 for (uint j = 0; j < rp_files_cnt; j++)
13176 {
13177 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13178 uint in_pos;
13179
13180 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13181
13182 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13183 {
13184 if (out_pos == RULES_MAX - 1)
13185 {
13186 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13187
13188 break;
13189 }
13190
13191 out->cmds[out_pos] = in->cmds[in_pos];
13192 }
13193 }
13194 }
13195
13196 local_free (repeats);
13197 }
13198 else if (rp_gen)
13199 {
13200 uint kernel_rules_avail = 0;
13201
13202 while (kernel_rules_cnt < rp_gen)
13203 {
13204 if (kernel_rules_avail == kernel_rules_cnt)
13205 {
13206 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13207
13208 kernel_rules_avail += INCR_RULES;
13209 }
13210
13211 memset (rule_buf, 0, HCBUFSIZ);
13212
13213 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13214
13215 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13216
13217 kernel_rules_cnt++;
13218 }
13219 }
13220 }
13221
13222 myfree (rule_buf);
13223
13224 /**
13225 * generate NOP rules
13226 */
13227
13228 if (kernel_rules_cnt == 0)
13229 {
13230 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13231
13232 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13233
13234 kernel_rules_cnt++;
13235 }
13236
13237 data.kernel_rules_cnt = kernel_rules_cnt;
13238 data.kernel_rules_buf = kernel_rules_buf;
13239
13240 /**
13241 * OpenCL platforms: detect
13242 */
13243
13244 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13245 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13246
13247 cl_uint platforms_cnt = 0;
13248 cl_uint platform_devices_cnt = 0;
13249
13250 if (keyspace == 0)
13251 {
13252 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13253
13254 if (platforms_cnt == 0)
13255 {
13256 log_info ("");
13257 log_info ("ATTENTION! No OpenCL compatible platform found");
13258 log_info ("");
13259 log_info ("You're probably missing the OpenCL runtime installation");
13260 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13261 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13262 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13263 log_info ("");
13264
13265 return (-1);
13266 }
13267
13268 if (opencl_platforms_filter != (uint) -1)
13269 {
13270 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13271
13272 if (opencl_platforms_filter > platform_cnt_mask)
13273 {
13274 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13275
13276 return (-1);
13277 }
13278 }
13279 }
13280
13281 /**
13282 * OpenCL device types:
13283 * 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.
13284 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13285 */
13286
13287 if (opencl_device_types == NULL)
13288 {
13289 cl_device_type device_types_all = 0;
13290
13291 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13292 {
13293 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13294
13295 cl_platform_id platform = platforms[platform_id];
13296
13297 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13298
13299 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13300 {
13301 cl_device_id device = platform_devices[platform_devices_id];
13302
13303 cl_device_type device_type;
13304
13305 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13306
13307 device_types_all |= device_type;
13308 }
13309 }
13310
13311 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13312 {
13313 device_types_filter |= CL_DEVICE_TYPE_CPU;
13314 }
13315 }
13316
13317 /**
13318 * OpenCL devices: simply push all devices from all platforms into the same device array
13319 */
13320
13321 int need_adl = 0;
13322 int need_nvapi = 0;
13323 int need_nvml = 0;
13324
13325 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13326
13327 data.devices_param = devices_param;
13328
13329 uint devices_cnt = 0;
13330
13331 uint devices_active = 0;
13332
13333 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13334 {
13335 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13336
13337 cl_platform_id platform = platforms[platform_id];
13338
13339 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13340
13341 char platform_vendor[INFOSZ] = { 0 };
13342
13343 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13344
13345 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13346 // this causes trouble with vendor id based macros
13347 // we'll assign generic to those without special optimization available
13348
13349 cl_uint platform_vendor_id = 0;
13350
13351 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13352 {
13353 platform_vendor_id = VENDOR_ID_AMD;
13354 }
13355 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13356 {
13357 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13358 }
13359 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13360 {
13361 platform_vendor_id = VENDOR_ID_APPLE;
13362 }
13363 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_MESA;
13374 }
13375 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13376 {
13377 platform_vendor_id = VENDOR_ID_NV;
13378 }
13379 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13380 {
13381 platform_vendor_id = VENDOR_ID_POCL;
13382 }
13383 else
13384 {
13385 platform_vendor_id = VENDOR_ID_GENERIC;
13386 }
13387
13388 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13389 {
13390 size_t param_value_size = 0;
13391
13392 const uint device_id = devices_cnt;
13393
13394 hc_device_param_t *device_param = &data.devices_param[device_id];
13395
13396 device_param->platform_vendor_id = platform_vendor_id;
13397
13398 device_param->device = platform_devices[platform_devices_id];
13399
13400 device_param->device_id = device_id;
13401
13402 device_param->platform_devices_id = platform_devices_id;
13403
13404 // device_type
13405
13406 cl_device_type device_type;
13407
13408 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13409
13410 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13411
13412 device_param->device_type = device_type;
13413
13414 // device_name
13415
13416 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13417
13418 char *device_name = (char *) mymalloc (param_value_size);
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13421
13422 device_param->device_name = device_name;
13423
13424 // device_vendor
13425
13426 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13427
13428 char *device_vendor = (char *) mymalloc (param_value_size);
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13431
13432 device_param->device_vendor = device_vendor;
13433
13434 cl_uint device_vendor_id = 0;
13435
13436 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13437 {
13438 device_vendor_id = VENDOR_ID_AMD;
13439 }
13440 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13441 {
13442 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13443 }
13444 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13445 {
13446 device_vendor_id = VENDOR_ID_APPLE;
13447 }
13448 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_INTEL_SDK;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_MESA;
13459 }
13460 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13461 {
13462 device_vendor_id = VENDOR_ID_NV;
13463 }
13464 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13465 {
13466 device_vendor_id = VENDOR_ID_POCL;
13467 }
13468 else
13469 {
13470 device_vendor_id = VENDOR_ID_GENERIC;
13471 }
13472
13473 device_param->device_vendor_id = device_vendor_id;
13474
13475 // tuning db
13476
13477 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13478
13479 // device_version
13480
13481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13482
13483 char *device_version = (char *) mymalloc (param_value_size);
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13486
13487 device_param->device_version = device_version;
13488
13489 // device_opencl_version
13490
13491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13492
13493 char *device_opencl_version = (char *) mymalloc (param_value_size);
13494
13495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13496
13497 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13498
13499 myfree (device_opencl_version);
13500
13501 // vector_width
13502
13503 cl_uint vector_width;
13504
13505 if (opencl_vector_width_chgd == 0)
13506 {
13507 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13508 {
13509 if (opti_type & OPTI_TYPE_USES_BITS_64)
13510 {
13511 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13512 }
13513 else
13514 {
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13516 }
13517 }
13518 else
13519 {
13520 vector_width = (cl_uint) tuningdb_entry->vector_width;
13521 }
13522 }
13523 else
13524 {
13525 vector_width = opencl_vector_width;
13526 }
13527
13528 if (vector_width > 16) vector_width = 16;
13529
13530 device_param->vector_width = vector_width;
13531
13532 // max_compute_units
13533
13534 cl_uint device_processors;
13535
13536 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13537
13538 device_param->device_processors = device_processors;
13539
13540 // device_maxmem_alloc
13541 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13542
13543 cl_ulong device_maxmem_alloc;
13544
13545 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13546
13547 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13548
13549 // device_global_mem
13550
13551 cl_ulong device_global_mem;
13552
13553 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13554
13555 device_param->device_global_mem = device_global_mem;
13556
13557 // max_work_group_size
13558
13559 size_t device_maxworkgroup_size;
13560
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13562
13563 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13564
13565 // max_clock_frequency
13566
13567 cl_uint device_maxclock_frequency;
13568
13569 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13570
13571 device_param->device_maxclock_frequency = device_maxclock_frequency;
13572
13573 // device_endian_little
13574
13575 cl_bool device_endian_little;
13576
13577 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13578
13579 if (device_endian_little == CL_FALSE)
13580 {
13581 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13582
13583 device_param->skipped = 1;
13584 }
13585
13586 // device_available
13587
13588 cl_bool device_available;
13589
13590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13591
13592 if (device_available == CL_FALSE)
13593 {
13594 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13595
13596 device_param->skipped = 1;
13597 }
13598
13599 // device_compiler_available
13600
13601 cl_bool device_compiler_available;
13602
13603 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13604
13605 if (device_compiler_available == CL_FALSE)
13606 {
13607 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13608
13609 device_param->skipped = 1;
13610 }
13611
13612 // device_execution_capabilities
13613
13614 cl_device_exec_capabilities device_execution_capabilities;
13615
13616 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13617
13618 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13619 {
13620 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13621
13622 device_param->skipped = 1;
13623 }
13624
13625 // device_extensions
13626
13627 size_t device_extensions_size;
13628
13629 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13630
13631 char *device_extensions = mymalloc (device_extensions_size + 1);
13632
13633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13634
13635 if (strstr (device_extensions, "base_atomics") == 0)
13636 {
13637 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13638
13639 device_param->skipped = 1;
13640 }
13641
13642 if (strstr (device_extensions, "byte_addressable_store") == 0)
13643 {
13644 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13645
13646 device_param->skipped = 1;
13647 }
13648
13649 myfree (device_extensions);
13650
13651 // device_local_mem_size
13652
13653 cl_ulong device_local_mem_size;
13654
13655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13656
13657 if (device_local_mem_size < 32768)
13658 {
13659 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13660
13661 device_param->skipped = 1;
13662 }
13663
13664 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13665 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13666 // This results in both utilizing it for 50%
13667 // However, Intel has much better SIMD control over their own hardware
13668 // It makes sense to give them full control over their own hardware
13669
13670 if (device_type & CL_DEVICE_TYPE_CPU)
13671 {
13672 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13673 {
13674 if (data.force == 0)
13675 {
13676 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13677 log_info (" You can use --force to override this but do not post error reports if you do so");
13678
13679 device_param->skipped = 1;
13680 }
13681 }
13682 }
13683
13684 // skipped
13685
13686 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13687 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13688
13689 // driver_version
13690
13691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13692
13693 char *driver_version = (char *) mymalloc (param_value_size);
13694
13695 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13696
13697 device_param->driver_version = driver_version;
13698
13699 // device_name_chksum
13700
13701 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13702
13703 #if __x86_64__
13704 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);
13705 #else
13706 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);
13707 #endif
13708
13709 uint device_name_digest[4] = { 0 };
13710
13711 md5_64 ((uint *) device_name_chksum, device_name_digest);
13712
13713 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13714
13715 device_param->device_name_chksum = device_name_chksum;
13716
13717 // device_processor_cores
13718
13719 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13720 {
13721 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13722 {
13723 need_adl = 1;
13724 }
13725
13726 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13727 {
13728 need_nvml = 1;
13729
13730 #ifdef _WIN
13731 need_nvapi = 1;
13732 #endif
13733 }
13734 }
13735
13736 // device_processor_cores
13737
13738 if (device_type & CL_DEVICE_TYPE_CPU)
13739 {
13740 cl_uint device_processor_cores = 1;
13741
13742 device_param->device_processor_cores = device_processor_cores;
13743 }
13744
13745 if (device_type & CL_DEVICE_TYPE_GPU)
13746 {
13747 if (device_vendor_id == VENDOR_ID_AMD)
13748 {
13749 cl_uint device_processor_cores = 0;
13750
13751 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13752
13753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13754
13755 device_param->device_processor_cores = device_processor_cores;
13756 }
13757 else if (device_vendor_id == VENDOR_ID_NV)
13758 {
13759 cl_uint kernel_exec_timeout = 0;
13760
13761 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13762
13763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13764
13765 device_param->kernel_exec_timeout = kernel_exec_timeout;
13766
13767 cl_uint device_processor_cores = 0;
13768
13769 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13770
13771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13772
13773 device_param->device_processor_cores = device_processor_cores;
13774
13775 cl_uint sm_minor = 0;
13776 cl_uint sm_major = 0;
13777
13778 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13779 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13780
13781 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13783
13784 device_param->sm_minor = sm_minor;
13785 device_param->sm_major = sm_major;
13786 }
13787 else
13788 {
13789 cl_uint device_processor_cores = 1;
13790
13791 device_param->device_processor_cores = device_processor_cores;
13792 }
13793 }
13794
13795 // display results
13796
13797 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13798 {
13799 if (machine_readable == 0)
13800 {
13801 if (device_param->skipped == 0)
13802 {
13803 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13804 device_id + 1,
13805 device_name,
13806 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13807 (unsigned int) (device_global_mem / 1024 / 1024),
13808 (unsigned int) device_processors);
13809 }
13810 else
13811 {
13812 log_info ("Device #%u: %s, skipped",
13813 device_id + 1,
13814 device_name);
13815 }
13816 }
13817 }
13818
13819 // common driver check
13820
13821 if (device_param->skipped == 0)
13822 {
13823 if (device_type & CL_DEVICE_TYPE_GPU)
13824 {
13825 if (platform_vendor_id == VENDOR_ID_AMD)
13826 {
13827 int catalyst_check = (force == 1) ? 0 : 1;
13828
13829 int catalyst_warn = 0;
13830
13831 int catalyst_broken = 0;
13832
13833 if (catalyst_check == 1)
13834 {
13835 catalyst_warn = 1;
13836
13837 // v14.9 and higher
13838 if (atoi (device_param->driver_version) >= 1573)
13839 {
13840 catalyst_warn = 0;
13841 }
13842
13843 catalyst_check = 0;
13844 }
13845
13846 if (catalyst_broken == 1)
13847 {
13848 log_info ("");
13849 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13850 log_info ("It will pass over cracked hashes and does not report them as cracked");
13851 log_info ("You are STRONGLY encouraged not to use it");
13852 log_info ("You can use --force to override this but do not post error reports if you do so");
13853 log_info ("");
13854
13855 return (-1);
13856 }
13857
13858 if (catalyst_warn == 1)
13859 {
13860 log_info ("");
13861 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13862 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13863 log_info ("See hashcat's homepage for official supported catalyst drivers");
13864 #ifdef _WIN
13865 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13866 #endif
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 else if (platform_vendor_id == VENDOR_ID_NV)
13874 {
13875 if (device_param->kernel_exec_timeout != 0)
13876 {
13877 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);
13878 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13879 }
13880 }
13881 }
13882
13883 /* turns out pocl still creates segfaults (because of llvm)
13884 if (device_type & CL_DEVICE_TYPE_CPU)
13885 {
13886 if (platform_vendor_id == VENDOR_ID_AMD)
13887 {
13888 if (force == 0)
13889 {
13890 log_info ("");
13891 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13892 log_info ("You are STRONGLY encouraged not to use it");
13893 log_info ("You can use --force to override this but do not post error reports if you do so");
13894 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13895 log_info ("");
13896
13897 return (-1);
13898 }
13899 }
13900 }
13901 */
13902
13903 /**
13904 * kernel accel and loops tuning db adjustment
13905 */
13906
13907 device_param->kernel_accel_min = 1;
13908 device_param->kernel_accel_max = 1024;
13909
13910 device_param->kernel_loops_min = 1;
13911 device_param->kernel_loops_max = 1024;
13912
13913 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13914
13915 if (tuningdb_entry)
13916 {
13917 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13918 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13919
13920 if (_kernel_accel)
13921 {
13922 device_param->kernel_accel_min = _kernel_accel;
13923 device_param->kernel_accel_max = _kernel_accel;
13924 }
13925
13926 if (_kernel_loops)
13927 {
13928 if (workload_profile == 1)
13929 {
13930 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13931 }
13932 else if (workload_profile == 2)
13933 {
13934 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13935 }
13936
13937 device_param->kernel_loops_min = _kernel_loops;
13938 device_param->kernel_loops_max = _kernel_loops;
13939 }
13940 }
13941
13942 // commandline parameters overwrite tuningdb entries
13943
13944 if (kernel_accel)
13945 {
13946 device_param->kernel_accel_min = kernel_accel;
13947 device_param->kernel_accel_max = kernel_accel;
13948 }
13949
13950 if (kernel_loops)
13951 {
13952 device_param->kernel_loops_min = kernel_loops;
13953 device_param->kernel_loops_max = kernel_loops;
13954 }
13955
13956 /**
13957 * activate device
13958 */
13959
13960 devices_active++;
13961 }
13962
13963 // next please
13964
13965 devices_cnt++;
13966 }
13967 }
13968
13969 if (keyspace == 0 && devices_active == 0)
13970 {
13971 log_error ("ERROR: No devices found/left");
13972
13973 return (-1);
13974 }
13975
13976 // 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)
13977
13978 if (devices_filter != (uint) -1)
13979 {
13980 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13981
13982 if (devices_filter > devices_cnt_mask)
13983 {
13984 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13985
13986 return (-1);
13987 }
13988 }
13989
13990 data.devices_cnt = devices_cnt;
13991
13992 data.devices_active = devices_active;
13993
13994 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13995 {
13996 if (machine_readable == 0)
13997 {
13998 log_info ("");
13999 }
14000 }
14001
14002 /**
14003 * HM devices: init
14004 */
14005
14006 #ifdef HAVE_HWMON
14007 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14008 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14009 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14010
14011 if (gpu_temp_disable == 0)
14012 {
14013 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14014 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14015 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14016
14017 data.hm_adl = NULL;
14018 data.hm_nvapi = NULL;
14019 data.hm_nvml = NULL;
14020
14021 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14022 {
14023 data.hm_nvml = nvml;
14024 }
14025
14026 if (data.hm_nvml)
14027 {
14028 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14029 {
14030 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14031
14032 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14033
14034 int tmp_out = 0;
14035
14036 for (int i = 0; i < tmp_in; i++)
14037 {
14038 hm_adapters_nvml[tmp_out++].adapter_index.nvml = nvmlGPUHandle[i];
14039 }
14040
14041 for (int i = 0; i < tmp_out; i++)
14042 {
14043 unsigned int speed;
14044
14045 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].adapter_index.nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14046
14047 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].adapter_index.nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14048
14049 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].adapter_index.nvml, NVML_GOM_ALL_ON);
14050 }
14051 }
14052 }
14053
14054 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14055 {
14056 data.hm_nvapi = nvapi;
14057 }
14058
14059 if (data.hm_nvapi)
14060 {
14061 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14062 {
14063 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14064
14065 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14066
14067 int tmp_out = 0;
14068
14069 for (int i = 0; i < tmp_in; i++)
14070 {
14071 hm_adapters_nvapi[tmp_out++].adapter_index.nvapi = nvGPUHandle[i];
14072 }
14073 }
14074 }
14075
14076 if ((need_adl == 1) && (adl_init (adl) == 0))
14077 {
14078 data.hm_adl = adl;
14079 }
14080
14081 if (data.hm_adl)
14082 {
14083 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14084 {
14085 // total number of adapters
14086
14087 int hm_adapters_num;
14088
14089 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14090
14091 // adapter info
14092
14093 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14094
14095 if (lpAdapterInfo == NULL) return (-1);
14096
14097 // get a list (of ids of) valid/usable adapters
14098
14099 int num_adl_adapters = 0;
14100
14101 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14102
14103 if (num_adl_adapters > 0)
14104 {
14105 hc_thread_mutex_lock (mux_adl);
14106
14107 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14108
14109 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14110
14111 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14112 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14113
14114 hc_thread_mutex_unlock (mux_adl);
14115 }
14116
14117 myfree (valid_adl_device_list);
14118 myfree (lpAdapterInfo);
14119 }
14120 }
14121
14122 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14123 {
14124 gpu_temp_disable = 1;
14125 }
14126 }
14127
14128 /**
14129 * OpenCL devices: allocate buffer for device specific information
14130 */
14131
14132 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14133 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14134
14135 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14136
14137 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14138
14139 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14140
14141 /**
14142 * User-defined GPU temp handling
14143 */
14144
14145 if (gpu_temp_disable == 1)
14146 {
14147 gpu_temp_abort = 0;
14148 gpu_temp_retain = 0;
14149 }
14150
14151 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14152 {
14153 if (gpu_temp_abort < gpu_temp_retain)
14154 {
14155 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14156
14157 return (-1);
14158 }
14159 }
14160
14161 data.gpu_temp_disable = gpu_temp_disable;
14162 data.gpu_temp_abort = gpu_temp_abort;
14163 data.gpu_temp_retain = gpu_temp_retain;
14164 #endif
14165
14166 /**
14167 * enable custom signal handler(s)
14168 */
14169
14170 if (benchmark == 0)
14171 {
14172 hc_signal (sigHandler_default);
14173 }
14174 else
14175 {
14176 hc_signal (sigHandler_benchmark);
14177 }
14178
14179 /**
14180 * inform the user
14181 */
14182
14183 if (data.quiet == 0)
14184 {
14185 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14186
14187 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);
14188
14189 if (attack_mode == ATTACK_MODE_STRAIGHT)
14190 {
14191 log_info ("Rules: %u", kernel_rules_cnt);
14192 }
14193
14194 if (opti_type)
14195 {
14196 log_info ("Applicable Optimizers:");
14197
14198 for (uint i = 0; i < 32; i++)
14199 {
14200 const uint opti_bit = 1u << i;
14201
14202 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14203 }
14204 }
14205
14206 /**
14207 * Watchdog and Temperature balance
14208 */
14209
14210 #ifdef HAVE_HWMON
14211 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14212 {
14213 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14214 }
14215
14216 if (gpu_temp_abort == 0)
14217 {
14218 log_info ("Watchdog: Temperature abort trigger disabled");
14219 }
14220 else
14221 {
14222 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14223 }
14224
14225 if (gpu_temp_retain == 0)
14226 {
14227 log_info ("Watchdog: Temperature retain trigger disabled");
14228 }
14229 else
14230 {
14231 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14232 }
14233
14234 if (data.quiet == 0) log_info ("");
14235 #endif
14236 }
14237
14238 #ifdef HAVE_HWMON
14239
14240 /**
14241 * HM devices: copy
14242 */
14243
14244 if (gpu_temp_disable == 0)
14245 {
14246 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14247 {
14248 hc_device_param_t *device_param = &data.devices_param[device_id];
14249
14250 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14251
14252 if (device_param->skipped) continue;
14253
14254 const uint platform_devices_id = device_param->platform_devices_id;
14255
14256 if (device_param->device_vendor_id == VENDOR_ID_NV)
14257 {
14258 memcpy (&data.hm_device[device_id], &hm_adapters_nvml[platform_devices_id], sizeof (hm_attrs_t));
14259 }
14260
14261 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14262 {
14263 memcpy (&data.hm_device[device_id], &hm_adapters_adl[platform_devices_id], sizeof (hm_attrs_t));
14264 }
14265 }
14266 }
14267
14268 /**
14269 * powertune on user request
14270 */
14271
14272 if (powertune_enable == 1)
14273 {
14274 hc_thread_mutex_lock (mux_adl);
14275
14276 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14277 {
14278 hc_device_param_t *device_param = &data.devices_param[device_id];
14279
14280 if (device_param->skipped) continue;
14281
14282 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14283 {
14284 /**
14285 * Temporary fix:
14286 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14287 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14288 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14289 * Driver / ADL bug?
14290 */
14291
14292 if (data.hm_device[device_id].od_version == 6)
14293 {
14294 int ADL_rc;
14295
14296 // check powertune capabilities first, if not available then skip device
14297
14298 int powertune_supported = 0;
14299
14300 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK)
14301 {
14302 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14303
14304 return (-1);
14305 }
14306
14307 // first backup current value, we will restore it later
14308
14309 if (powertune_supported != 0)
14310 {
14311 // powercontrol settings
14312
14313 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14314
14315 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune)) == ADL_OK)
14316 {
14317 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &od_power_control_status[device_id]);
14318 }
14319
14320 if (ADL_rc != ADL_OK)
14321 {
14322 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14323
14324 return (-1);
14325 }
14326
14327 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, powertune.iMaxValue)) != ADL_OK)
14328 {
14329 log_error ("ERROR: Failed to set new ADL PowerControl values");
14330
14331 return (-1);
14332 }
14333
14334 // clocks
14335
14336 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14337
14338 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14339
14340 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14341 {
14342 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14343
14344 return (-1);
14345 }
14346
14347 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14348
14349 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14350
14351 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &caps)) != ADL_OK)
14352 {
14353 log_error ("ERROR: Failed to get ADL device capabilities");
14354
14355 return (-1);
14356 }
14357
14358 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14359 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14360
14361 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14362 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14363
14364 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14365 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14366
14367 // warning if profile has too low max values
14368
14369 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14370 {
14371 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14372 }
14373
14374 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14375 {
14376 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14377 }
14378
14379 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14380
14381 performance_state->iNumberOfPerformanceLevels = 2;
14382
14383 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14384 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14385 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14386 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14387
14388 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14389 {
14390 log_info ("ERROR: Failed to set ADL performance state");
14391
14392 return (-1);
14393 }
14394
14395 local_free (performance_state);
14396 }
14397
14398 // set powertune value only
14399
14400 if (powertune_supported != 0)
14401 {
14402 // powertune set
14403 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14404
14405 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune)) != ADL_OK)
14406 {
14407 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14408
14409 return (-1);
14410 }
14411
14412 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, powertune.iMaxValue)) != ADL_OK)
14413 {
14414 log_error ("ERROR: Failed to set new ADL PowerControl values");
14415
14416 return (-1);
14417 }
14418 }
14419 }
14420 }
14421
14422 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14423 {
14424 // first backup current value, we will restore it later
14425
14426 unsigned int limit;
14427
14428 int powertune_supported = 0;
14429
14430 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &limit) == NVML_SUCCESS)
14431 {
14432 powertune_supported = 1;
14433 }
14434
14435 // if backup worked, activate the maximum allowed
14436
14437 if (powertune_supported != 0)
14438 {
14439 unsigned int minLimit;
14440 unsigned int maxLimit;
14441
14442 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14443 {
14444 if (maxLimit > 0)
14445 {
14446 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, maxLimit) == NVML_SUCCESS)
14447 {
14448 // now we can be sure we need to reset later
14449
14450 nvml_power_limit[device_id] = limit;
14451 }
14452 }
14453 }
14454 }
14455 }
14456 }
14457
14458 hc_thread_mutex_unlock (mux_adl);
14459 }
14460
14461 #endif // HAVE_HWMON
14462
14463 #ifdef DEBUG
14464 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14465 #endif
14466
14467 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14468
14469 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14470 {
14471 /**
14472 * host buffer
14473 */
14474
14475 hc_device_param_t *device_param = &data.devices_param[device_id];
14476
14477 if (device_param->skipped) continue;
14478
14479 /**
14480 * device properties
14481 */
14482
14483 const char *device_name_chksum = device_param->device_name_chksum;
14484 const u32 device_processors = device_param->device_processors;
14485 const u32 device_processor_cores = device_param->device_processor_cores;
14486
14487 /**
14488 * create context for each device
14489 */
14490
14491 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14492
14493 /**
14494 * create command-queue
14495 */
14496
14497 // not supported with NV
14498 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14499
14500 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14501
14502 /**
14503 * kernel threads: some algorithms need a fixed kernel-threads count
14504 * because of shared memory usage or bitslice
14505 * there needs to be some upper limit, otherwise there's too much overhead
14506 */
14507
14508 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14509
14510 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14511 {
14512 kernel_threads = KERNEL_THREADS_MAX_CPU;
14513 }
14514
14515 if (hash_mode == 1500) kernel_threads = 64; // DES
14516 if (hash_mode == 3000) kernel_threads = 64; // DES
14517 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14518 if (hash_mode == 7500) kernel_threads = 64; // RC4
14519 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14520 if (hash_mode == 9700) kernel_threads = 64; // RC4
14521 if (hash_mode == 9710) kernel_threads = 64; // RC4
14522 if (hash_mode == 9800) kernel_threads = 64; // RC4
14523 if (hash_mode == 9810) kernel_threads = 64; // RC4
14524 if (hash_mode == 10400) kernel_threads = 64; // RC4
14525 if (hash_mode == 10410) kernel_threads = 64; // RC4
14526 if (hash_mode == 10500) kernel_threads = 64; // RC4
14527 if (hash_mode == 13100) kernel_threads = 64; // RC4
14528
14529 device_param->kernel_threads = kernel_threads;
14530
14531 /**
14532 * create input buffers on device : calculate size of fixed memory buffers
14533 */
14534
14535 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14536 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14537
14538 device_param->size_root_css = size_root_css;
14539 device_param->size_markov_css = size_markov_css;
14540
14541 size_t size_results = sizeof (uint);
14542
14543 device_param->size_results = size_results;
14544
14545 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14546 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14547
14548 size_t size_plains = digests_cnt * sizeof (plain_t);
14549 size_t size_salts = salts_cnt * sizeof (salt_t);
14550 size_t size_esalts = salts_cnt * esalt_size;
14551
14552 device_param->size_plains = size_plains;
14553 device_param->size_digests = size_digests;
14554 device_param->size_shown = size_shown;
14555 device_param->size_salts = size_salts;
14556
14557 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14558 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14559 size_t size_tm = 32 * sizeof (bs_word_t);
14560
14561 // scryptV stuff
14562
14563 size_t size_scryptV = 1;
14564
14565 if ((hash_mode == 8900) || (hash_mode == 9300))
14566 {
14567 uint tmto_start = 0;
14568 uint tmto_stop = 10;
14569
14570 if (scrypt_tmto)
14571 {
14572 tmto_start = scrypt_tmto;
14573 }
14574 else
14575 {
14576 // in case the user did not specify the tmto manually
14577 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14578 // but set the lower end only in case the user has a device with too less memory
14579
14580 if (hash_mode == 8900)
14581 {
14582 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14583 {
14584 tmto_start = 1;
14585 }
14586 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14587 {
14588 tmto_start = 2;
14589 }
14590 }
14591 else if (hash_mode == 9300)
14592 {
14593 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14594 {
14595 tmto_start = 2;
14596 }
14597 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14598 {
14599 tmto_start = 2;
14600 }
14601 }
14602 }
14603
14604 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14605 {
14606 // TODO: in theory the following calculation needs to be done per salt, not global
14607 // we assume all hashes have the same scrypt settings
14608
14609 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14610
14611 size_scryptV /= 1 << tmto;
14612
14613 size_scryptV *= device_processors * device_processor_cores;
14614
14615 if (size_scryptV > device_param->device_maxmem_alloc)
14616 {
14617 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14618
14619 continue;
14620 }
14621
14622 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14623 {
14624 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14625 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14626 }
14627
14628 break;
14629 }
14630
14631 if (data.salts_buf[0].scrypt_phy == 0)
14632 {
14633 log_error ("ERROR: can't allocate enough device memory");
14634
14635 return -1;
14636 }
14637
14638 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14639 }
14640
14641 /**
14642 * some algorithms need a fixed kernel-loops count
14643 */
14644
14645 if (hash_mode == 1500)
14646 {
14647 const u32 kernel_loops_fixed = 1024;
14648
14649 device_param->kernel_loops_min = kernel_loops_fixed;
14650 device_param->kernel_loops_max = kernel_loops_fixed;
14651 }
14652
14653 if (hash_mode == 3000)
14654 {
14655 const u32 kernel_loops_fixed = 1024;
14656
14657 device_param->kernel_loops_min = kernel_loops_fixed;
14658 device_param->kernel_loops_max = kernel_loops_fixed;
14659 }
14660
14661 if (hash_mode == 8900)
14662 {
14663 const u32 kernel_loops_fixed = 1;
14664
14665 device_param->kernel_loops_min = kernel_loops_fixed;
14666 device_param->kernel_loops_max = kernel_loops_fixed;
14667 }
14668
14669 if (hash_mode == 9300)
14670 {
14671 const u32 kernel_loops_fixed = 1;
14672
14673 device_param->kernel_loops_min = kernel_loops_fixed;
14674 device_param->kernel_loops_max = kernel_loops_fixed;
14675 }
14676
14677 if (hash_mode == 12500)
14678 {
14679 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14680
14681 device_param->kernel_loops_min = kernel_loops_fixed;
14682 device_param->kernel_loops_max = kernel_loops_fixed;
14683 }
14684
14685 /**
14686 * some algorithms have a maximum kernel-loops count
14687 */
14688
14689 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14690 {
14691 u32 innerloop_cnt = 0;
14692
14693 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14694 {
14695 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14696 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14697 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14698 }
14699 else
14700 {
14701 innerloop_cnt = data.salts_buf[0].salt_iter;
14702 }
14703
14704 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14705 (innerloop_cnt <= device_param->kernel_loops_max))
14706 {
14707 device_param->kernel_loops_max = innerloop_cnt;
14708 }
14709 }
14710
14711 u32 kernel_accel_min = device_param->kernel_accel_min;
14712 u32 kernel_accel_max = device_param->kernel_accel_max;
14713
14714 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14715
14716 size_t size_pws = 4;
14717 size_t size_tmps = 4;
14718 size_t size_hooks = 4;
14719
14720 while (kernel_accel_max >= kernel_accel_min)
14721 {
14722 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14723
14724 // size_pws
14725
14726 size_pws = kernel_power_max * sizeof (pw_t);
14727
14728 // size_tmps
14729
14730 switch (hash_mode)
14731 {
14732 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14733 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14734 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14735 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14736 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14737 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14738 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14739 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14740 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14741 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14742 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14743 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14744 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14745 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14746 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14747 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14748 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14749 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14750 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14751 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14752 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14753 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14754 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14755 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14756 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14757 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14758 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14759 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14760 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14761 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14762 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14763 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14764 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14765 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14766 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14767 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14768 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14769 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14770 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14771 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14772 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14773 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14774 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14775 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14776 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14777 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14778 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14779 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14780 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14781 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14782 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14783 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14784 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14785 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14786 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14787 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14788 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14789 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14790 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14791 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14792 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14793 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14794 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14795 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14796 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14797 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14798 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14799 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14800 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14801 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14802 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14803 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14804 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14805 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14806 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14807 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14808 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14809 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14810 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14811 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14812 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14813 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14814 };
14815
14816 // size_hooks
14817
14818 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14819 {
14820 // none yet
14821 }
14822
14823 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14824 // if not, decrease amplifier and try again
14825
14826 int skip = 0;
14827
14828 const u64 size_total
14829 = bitmap_size
14830 + bitmap_size
14831 + bitmap_size
14832 + bitmap_size
14833 + bitmap_size
14834 + bitmap_size
14835 + bitmap_size
14836 + bitmap_size
14837 + size_bfs
14838 + size_combs
14839 + size_digests
14840 + size_esalts
14841 + size_hooks
14842 + size_markov_css
14843 + size_plains
14844 + size_pws
14845 + size_pws // not a bug
14846 + size_results
14847 + size_root_css
14848 + size_rules
14849 + size_rules_c
14850 + size_salts
14851 + size_scryptV
14852 + size_shown
14853 + size_tm
14854 + size_tmps;
14855
14856 // Don't ask me, ask AMD!
14857
14858 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14859 if (size_total > device_param->device_global_mem) skip = 1;
14860
14861 if (skip == 1)
14862 {
14863 kernel_accel_max--;
14864
14865 continue;
14866 }
14867
14868 break;
14869 }
14870
14871 /*
14872 if (kernel_accel_max == 0)
14873 {
14874 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14875
14876 return -1;
14877 }
14878 */
14879
14880 device_param->kernel_accel_min = kernel_accel_min;
14881 device_param->kernel_accel_max = kernel_accel_max;
14882
14883 /*
14884 if (kernel_accel_max < kernel_accel)
14885 {
14886 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14887
14888 device_param->kernel_accel = kernel_accel_max;
14889 }
14890 */
14891
14892 device_param->size_bfs = size_bfs;
14893 device_param->size_combs = size_combs;
14894 device_param->size_rules = size_rules;
14895 device_param->size_rules_c = size_rules_c;
14896 device_param->size_pws = size_pws;
14897 device_param->size_tmps = size_tmps;
14898 device_param->size_hooks = size_hooks;
14899
14900 /**
14901 * default building options
14902 */
14903
14904 char build_opts[1024] = { 0 };
14905
14906 // we don't have sm_* on vendors not NV but it doesn't matter
14907
14908 #if _WIN
14909 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);
14910 #else
14911 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);
14912 #endif
14913
14914 char build_opts_new[1024] = { 0 };
14915
14916 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);
14917
14918 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14919
14920 /*
14921 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14922 {
14923 // we do vectorizing much better than the auto-vectorizer
14924
14925 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14926
14927 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14928 }
14929 */
14930
14931 #ifdef DEBUG
14932 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14933 #endif
14934
14935 /**
14936 * main kernel
14937 */
14938
14939 {
14940 /**
14941 * kernel source filename
14942 */
14943
14944 char source_file[256] = { 0 };
14945
14946 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14947
14948 struct stat sst;
14949
14950 if (stat (source_file, &sst) == -1)
14951 {
14952 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14953
14954 return -1;
14955 }
14956
14957 /**
14958 * kernel cached filename
14959 */
14960
14961 char cached_file[256] = { 0 };
14962
14963 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14964
14965 int cached = 1;
14966
14967 struct stat cst;
14968
14969 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14970 {
14971 cached = 0;
14972 }
14973
14974 /**
14975 * kernel compile or load
14976 */
14977
14978 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14979
14980 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14981
14982 if (force_jit_compilation == -1)
14983 {
14984 if (cached == 0)
14985 {
14986 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14987
14988 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14989
14990 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14991
14992 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14993
14994 #ifdef DEBUG
14995 size_t build_log_size = 0;
14996
14997 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14998
14999 if (build_log_size > 1)
15000 {
15001 char *build_log = (char *) malloc (build_log_size + 1);
15002
15003 memset (build_log, 0, build_log_size + 1);
15004
15005 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15006
15007 puts (build_log);
15008
15009 free (build_log);
15010 }
15011 #endif
15012
15013 if (rc != 0)
15014 {
15015 device_param->skipped = true;
15016
15017 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15018
15019 continue;
15020 }
15021
15022 size_t binary_size;
15023
15024 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15025
15026 u8 *binary = (u8 *) mymalloc (binary_size);
15027
15028 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15029
15030 writeProgramBin (cached_file, binary, binary_size);
15031
15032 local_free (binary);
15033 }
15034 else
15035 {
15036 #ifdef DEBUG
15037 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15038 #endif
15039
15040 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15041
15042 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15043
15044 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15045 }
15046 }
15047 else
15048 {
15049 #ifdef DEBUG
15050 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15051 #endif
15052
15053 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15054
15055 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15056
15057 char build_opts_update[1024] = { 0 };
15058
15059 if (force_jit_compilation == 1500)
15060 {
15061 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15062 }
15063 else if (force_jit_compilation == 8900)
15064 {
15065 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);
15066 }
15067 else
15068 {
15069 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15070 }
15071
15072 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15073
15074 #ifdef DEBUG
15075 size_t build_log_size = 0;
15076
15077 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15078
15079 if (build_log_size > 1)
15080 {
15081 char *build_log = (char *) malloc (build_log_size + 1);
15082
15083 memset (build_log, 0, build_log_size + 1);
15084
15085 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15086
15087 puts (build_log);
15088
15089 free (build_log);
15090 }
15091 #endif
15092
15093 if (rc != 0)
15094 {
15095 device_param->skipped = true;
15096
15097 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15098 }
15099 }
15100
15101 local_free (kernel_lengths);
15102 local_free (kernel_sources[0]);
15103 local_free (kernel_sources);
15104 }
15105
15106 /**
15107 * word generator kernel
15108 */
15109
15110 if (attack_mode != ATTACK_MODE_STRAIGHT)
15111 {
15112 /**
15113 * kernel mp source filename
15114 */
15115
15116 char source_file[256] = { 0 };
15117
15118 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15119
15120 struct stat sst;
15121
15122 if (stat (source_file, &sst) == -1)
15123 {
15124 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15125
15126 return -1;
15127 }
15128
15129 /**
15130 * kernel mp cached filename
15131 */
15132
15133 char cached_file[256] = { 0 };
15134
15135 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15136
15137 int cached = 1;
15138
15139 struct stat cst;
15140
15141 if (stat (cached_file, &cst) == -1)
15142 {
15143 cached = 0;
15144 }
15145
15146 /**
15147 * kernel compile or load
15148 */
15149
15150 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15151
15152 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15153
15154 if (cached == 0)
15155 {
15156 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15157 if (quiet == 0) log_info ("");
15158
15159 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15160
15161 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15162
15163 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15164
15165 if (rc != 0)
15166 {
15167 device_param->skipped = true;
15168
15169 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15170
15171 continue;
15172 }
15173
15174 size_t binary_size;
15175
15176 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15177
15178 u8 *binary = (u8 *) mymalloc (binary_size);
15179
15180 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15181
15182 writeProgramBin (cached_file, binary, binary_size);
15183
15184 local_free (binary);
15185 }
15186 else
15187 {
15188 #ifdef DEBUG
15189 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15190 #endif
15191
15192 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15193
15194 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15195
15196 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15197 }
15198
15199 local_free (kernel_lengths);
15200 local_free (kernel_sources[0]);
15201 local_free (kernel_sources);
15202 }
15203
15204 /**
15205 * amplifier kernel
15206 */
15207
15208 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15209 {
15210
15211 }
15212 else
15213 {
15214 /**
15215 * kernel amp source filename
15216 */
15217
15218 char source_file[256] = { 0 };
15219
15220 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15221
15222 struct stat sst;
15223
15224 if (stat (source_file, &sst) == -1)
15225 {
15226 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15227
15228 return -1;
15229 }
15230
15231 /**
15232 * kernel amp cached filename
15233 */
15234
15235 char cached_file[256] = { 0 };
15236
15237 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15238
15239 int cached = 1;
15240
15241 struct stat cst;
15242
15243 if (stat (cached_file, &cst) == -1)
15244 {
15245 cached = 0;
15246 }
15247
15248 /**
15249 * kernel compile or load
15250 */
15251
15252 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15253
15254 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15255
15256 if (cached == 0)
15257 {
15258 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15259 if (quiet == 0) log_info ("");
15260
15261 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15262
15263 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15264
15265 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15266
15267 if (rc != 0)
15268 {
15269 device_param->skipped = true;
15270
15271 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15272
15273 continue;
15274 }
15275
15276 size_t binary_size;
15277
15278 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15279
15280 u8 *binary = (u8 *) mymalloc (binary_size);
15281
15282 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15283
15284 writeProgramBin (cached_file, binary, binary_size);
15285
15286 local_free (binary);
15287 }
15288 else
15289 {
15290 #ifdef DEBUG
15291 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15292 #endif
15293
15294 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15295
15296 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15297
15298 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15299 }
15300
15301 local_free (kernel_lengths);
15302 local_free (kernel_sources[0]);
15303 local_free (kernel_sources);
15304 }
15305
15306 // some algorithm collide too fast, make that impossible
15307
15308 if (benchmark == 1)
15309 {
15310 ((uint *) digests_buf)[0] = -1;
15311 ((uint *) digests_buf)[1] = -1;
15312 ((uint *) digests_buf)[2] = -1;
15313 ((uint *) digests_buf)[3] = -1;
15314 }
15315
15316 /**
15317 * global buffers
15318 */
15319
15320 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15321 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15322 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15323 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15324 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15325 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15326 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15327 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15328 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15329 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15330 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15331 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15332 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15333 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15334 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15335 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15336 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15337 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15338
15339 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);
15340 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);
15341 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);
15342 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);
15343 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);
15344 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);
15345 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);
15346 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);
15347 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15348 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15349 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15350
15351 /**
15352 * special buffers
15353 */
15354
15355 if (attack_kern == ATTACK_KERN_STRAIGHT)
15356 {
15357 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15358 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15359
15360 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15361 }
15362 else if (attack_kern == ATTACK_KERN_COMBI)
15363 {
15364 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15365 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15366 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15367 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15368 }
15369 else if (attack_kern == ATTACK_KERN_BF)
15370 {
15371 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15372 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15373 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15374 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15375 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15376 }
15377
15378 if (size_esalts)
15379 {
15380 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15381
15382 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15383 }
15384
15385 /**
15386 * main host data
15387 */
15388
15389 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15390
15391 device_param->pws_buf = pws_buf;
15392
15393 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15394
15395 device_param->combs_buf = combs_buf;
15396
15397 void *hooks_buf = mymalloc (size_hooks);
15398
15399 device_param->hooks_buf = hooks_buf;
15400
15401 /**
15402 * kernel args
15403 */
15404
15405 device_param->kernel_params_buf32[21] = bitmap_mask;
15406 device_param->kernel_params_buf32[22] = bitmap_shift1;
15407 device_param->kernel_params_buf32[23] = bitmap_shift2;
15408 device_param->kernel_params_buf32[24] = 0; // salt_pos
15409 device_param->kernel_params_buf32[25] = 0; // loop_pos
15410 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15411 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15412 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15413 device_param->kernel_params_buf32[29] = 0; // digests_offset
15414 device_param->kernel_params_buf32[30] = 0; // combs_mode
15415 device_param->kernel_params_buf32[31] = 0; // gid_max
15416
15417 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15418 ? &device_param->d_pws_buf
15419 : &device_param->d_pws_amp_buf;
15420 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15421 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15422 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15423 device_param->kernel_params[ 4] = &device_param->d_tmps;
15424 device_param->kernel_params[ 5] = &device_param->d_hooks;
15425 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15426 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15427 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15428 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15429 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15430 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15431 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15432 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15433 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15434 device_param->kernel_params[15] = &device_param->d_digests_buf;
15435 device_param->kernel_params[16] = &device_param->d_digests_shown;
15436 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15437 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15438 device_param->kernel_params[19] = &device_param->d_result;
15439 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15440 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15441 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15442 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15443 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15444 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15445 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15446 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15447 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15448 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15449 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15450 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15451
15452 device_param->kernel_params_mp_buf64[3] = 0;
15453 device_param->kernel_params_mp_buf32[4] = 0;
15454 device_param->kernel_params_mp_buf32[5] = 0;
15455 device_param->kernel_params_mp_buf32[6] = 0;
15456 device_param->kernel_params_mp_buf32[7] = 0;
15457 device_param->kernel_params_mp_buf32[8] = 0;
15458
15459 device_param->kernel_params_mp[0] = NULL;
15460 device_param->kernel_params_mp[1] = NULL;
15461 device_param->kernel_params_mp[2] = NULL;
15462 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15463 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15464 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15465 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15466 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15467 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15468
15469 device_param->kernel_params_mp_l_buf64[3] = 0;
15470 device_param->kernel_params_mp_l_buf32[4] = 0;
15471 device_param->kernel_params_mp_l_buf32[5] = 0;
15472 device_param->kernel_params_mp_l_buf32[6] = 0;
15473 device_param->kernel_params_mp_l_buf32[7] = 0;
15474 device_param->kernel_params_mp_l_buf32[8] = 0;
15475 device_param->kernel_params_mp_l_buf32[9] = 0;
15476
15477 device_param->kernel_params_mp_l[0] = NULL;
15478 device_param->kernel_params_mp_l[1] = NULL;
15479 device_param->kernel_params_mp_l[2] = NULL;
15480 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15481 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15482 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15483 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15484 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15485 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15486 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15487
15488 device_param->kernel_params_mp_r_buf64[3] = 0;
15489 device_param->kernel_params_mp_r_buf32[4] = 0;
15490 device_param->kernel_params_mp_r_buf32[5] = 0;
15491 device_param->kernel_params_mp_r_buf32[6] = 0;
15492 device_param->kernel_params_mp_r_buf32[7] = 0;
15493 device_param->kernel_params_mp_r_buf32[8] = 0;
15494
15495 device_param->kernel_params_mp_r[0] = NULL;
15496 device_param->kernel_params_mp_r[1] = NULL;
15497 device_param->kernel_params_mp_r[2] = NULL;
15498 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15499 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15500 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15501 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15502 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15503 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15504
15505 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15506 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15507
15508 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15509 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15510 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15511 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15512 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15513 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15514 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15515
15516 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15517 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15518
15519 device_param->kernel_params_memset_buf32[1] = 0; // value
15520 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15521
15522 device_param->kernel_params_memset[0] = NULL;
15523 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15524 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15525
15526 /**
15527 * kernel name
15528 */
15529
15530 size_t kernel_wgs_tmp;
15531
15532 char kernel_name[64] = { 0 };
15533
15534 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15535 {
15536 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15537 {
15538 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15539
15540 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15541
15542 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15543
15544 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15545
15546 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15547
15548 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15549 }
15550 else
15551 {
15552 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15553
15554 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15555
15556 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15557
15558 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15559
15560 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15561
15562 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15563 }
15564
15565 if (data.attack_mode == ATTACK_MODE_BF)
15566 {
15567 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15568 {
15569 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15570
15571 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15572
15573 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);
15574 }
15575 }
15576 }
15577 else
15578 {
15579 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15580
15581 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15582
15583 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15584
15585 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15586
15587 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15588
15589 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15590
15591 if (opts_type & OPTS_TYPE_HOOK12)
15592 {
15593 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15594
15595 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15596
15597 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);
15598 }
15599
15600 if (opts_type & OPTS_TYPE_HOOK23)
15601 {
15602 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15603
15604 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15605
15606 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);
15607 }
15608 }
15609
15610 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);
15611 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);
15612 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);
15613
15614 for (uint i = 0; i <= 20; i++)
15615 {
15616 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15617 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15618 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15619
15620 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15621 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15622 }
15623
15624 for (uint i = 21; i <= 31; i++)
15625 {
15626 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15627 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15628 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15629
15630 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15631 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15632 }
15633
15634 // GPU memset
15635
15636 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15637
15638 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);
15639
15640 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15641 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15642 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15643
15644 // MP start
15645
15646 if (attack_mode == ATTACK_MODE_BF)
15647 {
15648 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15649 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15650
15651 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);
15652 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);
15653
15654 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15655 {
15656 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15657 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15658 }
15659 }
15660 else if (attack_mode == ATTACK_MODE_HYBRID1)
15661 {
15662 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15663
15664 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);
15665 }
15666 else if (attack_mode == ATTACK_MODE_HYBRID2)
15667 {
15668 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15669
15670 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);
15671 }
15672
15673 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15674 {
15675 // nothing to do
15676 }
15677 else
15678 {
15679 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15680
15681 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);
15682 }
15683
15684 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15685 {
15686 // nothing to do
15687 }
15688 else
15689 {
15690 for (uint i = 0; i < 5; i++)
15691 {
15692 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15693 }
15694
15695 for (uint i = 5; i < 7; i++)
15696 {
15697 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15698 }
15699 }
15700
15701 // maybe this has been updated by clGetKernelWorkGroupInfo()
15702 // value can only be decreased, so we don't need to reallocate buffers
15703
15704 device_param->kernel_threads = kernel_threads;
15705
15706 // zero some data buffers
15707
15708 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15709 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15710 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15711 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15712 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15713 run_kernel_bzero (device_param, device_param->d_result, size_results);
15714
15715 /**
15716 * special buffers
15717 */
15718
15719 if (attack_kern == ATTACK_KERN_STRAIGHT)
15720 {
15721 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15722 }
15723 else if (attack_kern == ATTACK_KERN_COMBI)
15724 {
15725 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15726 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15727 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15728 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15729 }
15730 else if (attack_kern == ATTACK_KERN_BF)
15731 {
15732 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15733 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15734 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15735 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15736 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15737 }
15738
15739 #if defined(HAVE_HWMON)
15740
15741 /**
15742 * Store thermal target temperature so we can send a notice to user
15743 */
15744
15745 if (gpu_temp_disable == 0)
15746 {
15747 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15748 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15749
15750 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15751 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15752
15753 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15754 }
15755
15756 /**
15757 * Store initial fanspeed if gpu_temp_retain is enabled
15758 */
15759
15760 if (gpu_temp_disable == 0)
15761 {
15762 if (gpu_temp_retain != 0)
15763 {
15764 hc_thread_mutex_lock (mux_adl);
15765
15766 if (data.hm_device[device_id].fan_get_supported == 1)
15767 {
15768 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15769 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15770
15771 temp_retain_fanspeed_value[device_id] = fanspeed;
15772 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15773
15774 // we also set it to tell the OS we take control over the fan and it's automatic controller
15775 // if it was set to automatic. we do not control user-defined fanspeeds.
15776
15777 if (fanpolicy == 1)
15778 {
15779 data.hm_device[device_id].fan_set_supported = 1;
15780
15781 int rc = -1;
15782
15783 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15784 {
15785 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15786 }
15787 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15788 {
15789
15790 }
15791
15792 if (rc == 0)
15793 {
15794 data.hm_device[device_id].fan_set_supported = 1;
15795 }
15796 else
15797 {
15798 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15799
15800 data.hm_device[device_id].fan_set_supported = 0;
15801 }
15802 }
15803 else
15804 {
15805 data.hm_device[device_id].fan_set_supported = 0;
15806 }
15807 }
15808
15809 hc_thread_mutex_unlock (mux_adl);
15810 }
15811 }
15812
15813 #endif // HAVE_HWMON
15814 }
15815
15816 if (data.quiet == 0) log_info_nn ("");
15817
15818 /**
15819 * In benchmark-mode, inform user which algorithm is checked
15820 */
15821
15822 if (benchmark == 1)
15823 {
15824 if (machine_readable == 0)
15825 {
15826 quiet = 0;
15827
15828 data.quiet = quiet;
15829
15830 char *hash_type = strhashtype (data.hash_mode); // not a bug
15831
15832 log_info ("Hashtype: %s", hash_type);
15833 log_info ("");
15834 }
15835 }
15836
15837 /**
15838 * keep track of the progress
15839 */
15840
15841 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15842 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15843 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15844
15845 /**
15846 * open filehandles
15847 */
15848
15849 #if _WIN
15850 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15851 {
15852 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15853
15854 return (-1);
15855 }
15856
15857 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15858 {
15859 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15860
15861 return (-1);
15862 }
15863
15864 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15865 {
15866 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15867
15868 return (-1);
15869 }
15870 #endif
15871
15872 /**
15873 * dictionary pad
15874 */
15875
15876 segment_size *= (1024 * 1024);
15877
15878 data.segment_size = segment_size;
15879
15880 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15881
15882 wl_data->buf = (char *) mymalloc (segment_size);
15883 wl_data->avail = segment_size;
15884 wl_data->incr = segment_size;
15885 wl_data->cnt = 0;
15886 wl_data->pos = 0;
15887
15888 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15889
15890 data.wordlist_mode = wordlist_mode;
15891
15892 cs_t *css_buf = NULL;
15893 uint css_cnt = 0;
15894 uint dictcnt = 0;
15895 uint maskcnt = 1;
15896 char **masks = NULL;
15897 char **dictfiles = NULL;
15898
15899 uint mask_from_file = 0;
15900
15901 if (attack_mode == ATTACK_MODE_STRAIGHT)
15902 {
15903 if (wordlist_mode == WL_MODE_FILE)
15904 {
15905 int wls_left = myargc - (optind + 1);
15906
15907 for (int i = 0; i < wls_left; i++)
15908 {
15909 char *l0_filename = myargv[optind + 1 + i];
15910
15911 struct stat l0_stat;
15912
15913 if (stat (l0_filename, &l0_stat) == -1)
15914 {
15915 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15916
15917 return (-1);
15918 }
15919
15920 uint is_dir = S_ISDIR (l0_stat.st_mode);
15921
15922 if (is_dir == 0)
15923 {
15924 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15925
15926 dictcnt++;
15927
15928 dictfiles[dictcnt - 1] = l0_filename;
15929 }
15930 else
15931 {
15932 // do not allow --keyspace w/ a directory
15933
15934 if (keyspace == 1)
15935 {
15936 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15937
15938 return (-1);
15939 }
15940
15941 char **dictionary_files = NULL;
15942
15943 dictionary_files = scan_directory (l0_filename);
15944
15945 if (dictionary_files != NULL)
15946 {
15947 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15948
15949 for (int d = 0; dictionary_files[d] != NULL; d++)
15950 {
15951 char *l1_filename = dictionary_files[d];
15952
15953 struct stat l1_stat;
15954
15955 if (stat (l1_filename, &l1_stat) == -1)
15956 {
15957 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15958
15959 return (-1);
15960 }
15961
15962 if (S_ISREG (l1_stat.st_mode))
15963 {
15964 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15965
15966 dictcnt++;
15967
15968 dictfiles[dictcnt - 1] = strdup (l1_filename);
15969 }
15970 }
15971 }
15972
15973 local_free (dictionary_files);
15974 }
15975 }
15976
15977 if (dictcnt < 1)
15978 {
15979 log_error ("ERROR: No usable dictionary file found.");
15980
15981 return (-1);
15982 }
15983 }
15984 else if (wordlist_mode == WL_MODE_STDIN)
15985 {
15986 dictcnt = 1;
15987 }
15988 }
15989 else if (attack_mode == ATTACK_MODE_COMBI)
15990 {
15991 // display
15992
15993 char *dictfile1 = myargv[optind + 1 + 0];
15994 char *dictfile2 = myargv[optind + 1 + 1];
15995
15996 // find the bigger dictionary and use as base
15997
15998 FILE *fp1 = NULL;
15999 FILE *fp2 = NULL;
16000
16001 struct stat tmp_stat;
16002
16003 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16004 {
16005 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16006
16007 return (-1);
16008 }
16009
16010 if (stat (dictfile1, &tmp_stat) == -1)
16011 {
16012 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16013
16014 fclose (fp1);
16015
16016 return (-1);
16017 }
16018
16019 if (S_ISDIR (tmp_stat.st_mode))
16020 {
16021 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16022
16023 fclose (fp1);
16024
16025 return (-1);
16026 }
16027
16028 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16029 {
16030 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16031
16032 fclose (fp1);
16033
16034 return (-1);
16035 }
16036
16037 if (stat (dictfile2, &tmp_stat) == -1)
16038 {
16039 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16040
16041 fclose (fp1);
16042 fclose (fp2);
16043
16044 return (-1);
16045 }
16046
16047 if (S_ISDIR (tmp_stat.st_mode))
16048 {
16049 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16050
16051 fclose (fp1);
16052 fclose (fp2);
16053
16054 return (-1);
16055 }
16056
16057 data.combs_cnt = 1;
16058
16059 data.quiet = 1;
16060
16061 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16062
16063 data.quiet = quiet;
16064
16065 if (words1_cnt == 0)
16066 {
16067 log_error ("ERROR: %s: empty file", dictfile1);
16068
16069 fclose (fp1);
16070 fclose (fp2);
16071
16072 return (-1);
16073 }
16074
16075 data.combs_cnt = 1;
16076
16077 data.quiet = 1;
16078
16079 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16080
16081 data.quiet = quiet;
16082
16083 if (words2_cnt == 0)
16084 {
16085 log_error ("ERROR: %s: empty file", dictfile2);
16086
16087 fclose (fp1);
16088 fclose (fp2);
16089
16090 return (-1);
16091 }
16092
16093 fclose (fp1);
16094 fclose (fp2);
16095
16096 data.dictfile = dictfile1;
16097 data.dictfile2 = dictfile2;
16098
16099 if (words1_cnt >= words2_cnt)
16100 {
16101 data.combs_cnt = words2_cnt;
16102 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16103
16104 dictfiles = &data.dictfile;
16105
16106 dictcnt = 1;
16107 }
16108 else
16109 {
16110 data.combs_cnt = words1_cnt;
16111 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16112
16113 dictfiles = &data.dictfile2;
16114
16115 dictcnt = 1;
16116
16117 // we also have to switch wordlist related rules!
16118
16119 char *tmpc = data.rule_buf_l;
16120
16121 data.rule_buf_l = data.rule_buf_r;
16122 data.rule_buf_r = tmpc;
16123
16124 int tmpi = data.rule_len_l;
16125
16126 data.rule_len_l = data.rule_len_r;
16127 data.rule_len_r = tmpi;
16128 }
16129 }
16130 else if (attack_mode == ATTACK_MODE_BF)
16131 {
16132 char *mask = NULL;
16133
16134 maskcnt = 0;
16135
16136 if (benchmark == 0)
16137 {
16138 mask = myargv[optind + 1];
16139
16140 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16141
16142 if ((optind + 2) <= myargc)
16143 {
16144 struct stat file_stat;
16145
16146 if (stat (mask, &file_stat) == -1)
16147 {
16148 maskcnt = 1;
16149
16150 masks[maskcnt - 1] = mystrdup (mask);
16151 }
16152 else
16153 {
16154 int wls_left = myargc - (optind + 1);
16155
16156 uint masks_avail = INCR_MASKS;
16157
16158 for (int i = 0; i < wls_left; i++)
16159 {
16160 if (i != 0)
16161 {
16162 mask = myargv[optind + 1 + i];
16163
16164 if (stat (mask, &file_stat) == -1)
16165 {
16166 log_error ("ERROR: %s: %s", mask, strerror (errno));
16167
16168 return (-1);
16169 }
16170 }
16171
16172 uint is_file = S_ISREG (file_stat.st_mode);
16173
16174 if (is_file == 1)
16175 {
16176 FILE *mask_fp;
16177
16178 if ((mask_fp = fopen (mask, "r")) == NULL)
16179 {
16180 log_error ("ERROR: %s: %s", mask, strerror (errno));
16181
16182 return (-1);
16183 }
16184
16185 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16186
16187 while (!feof (mask_fp))
16188 {
16189 memset (line_buf, 0, HCBUFSIZ);
16190
16191 int line_len = fgetl (mask_fp, line_buf);
16192
16193 if (line_len == 0) continue;
16194
16195 if (line_buf[0] == '#') continue;
16196
16197 if (masks_avail == maskcnt)
16198 {
16199 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16200
16201 masks_avail += INCR_MASKS;
16202 }
16203
16204 masks[maskcnt] = mystrdup (line_buf);
16205
16206 maskcnt++;
16207 }
16208
16209 myfree (line_buf);
16210
16211 fclose (mask_fp);
16212 }
16213 else
16214 {
16215 log_error ("ERROR: %s: unsupported file-type", mask);
16216
16217 return (-1);
16218 }
16219 }
16220
16221 mask_from_file = 1;
16222 }
16223 }
16224 else
16225 {
16226 custom_charset_1 = (char *) "?l?d?u";
16227 custom_charset_2 = (char *) "?l?d";
16228 custom_charset_3 = (char *) "?l?d*!$@_";
16229
16230 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16231 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16232 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16233
16234 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16235
16236 wordlist_mode = WL_MODE_MASK;
16237
16238 data.wordlist_mode = wordlist_mode;
16239
16240 increment = 1;
16241
16242 maskcnt = 1;
16243 }
16244 }
16245 else
16246 {
16247 /**
16248 * generate full masks and charsets
16249 */
16250
16251 masks = (char **) mymalloc (sizeof (char *));
16252
16253 switch (hash_mode)
16254 {
16255 case 1731: pw_min = 5;
16256 pw_max = 5;
16257 mask = mystrdup ("?b?b?b?b?b");
16258 break;
16259 case 12500: pw_min = 5;
16260 pw_max = 5;
16261 mask = mystrdup ("?b?b?b?b?b");
16262 break;
16263 default: pw_min = 7;
16264 pw_max = 7;
16265 mask = mystrdup ("?b?b?b?b?b?b?b");
16266 break;
16267 }
16268
16269 maskcnt = 1;
16270
16271 masks[maskcnt - 1] = mystrdup (mask);
16272
16273 wordlist_mode = WL_MODE_MASK;
16274
16275 data.wordlist_mode = wordlist_mode;
16276
16277 increment = 1;
16278 }
16279
16280 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16281
16282 if (increment)
16283 {
16284 if (increment_min > pw_min) pw_min = increment_min;
16285
16286 if (increment_max < pw_max) pw_max = increment_max;
16287 }
16288 }
16289 else if (attack_mode == ATTACK_MODE_HYBRID1)
16290 {
16291 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16292
16293 // display
16294
16295 char *mask = myargv[myargc - 1];
16296
16297 maskcnt = 0;
16298
16299 masks = (char **) mymalloc (1 * sizeof (char *));
16300
16301 // mod
16302
16303 struct stat file_stat;
16304
16305 if (stat (mask, &file_stat) == -1)
16306 {
16307 maskcnt = 1;
16308
16309 masks[maskcnt - 1] = mystrdup (mask);
16310 }
16311 else
16312 {
16313 uint is_file = S_ISREG (file_stat.st_mode);
16314
16315 if (is_file == 1)
16316 {
16317 FILE *mask_fp;
16318
16319 if ((mask_fp = fopen (mask, "r")) == NULL)
16320 {
16321 log_error ("ERROR: %s: %s", mask, strerror (errno));
16322
16323 return (-1);
16324 }
16325
16326 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16327
16328 uint masks_avail = 1;
16329
16330 while (!feof (mask_fp))
16331 {
16332 memset (line_buf, 0, HCBUFSIZ);
16333
16334 int line_len = fgetl (mask_fp, line_buf);
16335
16336 if (line_len == 0) continue;
16337
16338 if (line_buf[0] == '#') continue;
16339
16340 if (masks_avail == maskcnt)
16341 {
16342 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16343
16344 masks_avail += INCR_MASKS;
16345 }
16346
16347 masks[maskcnt] = mystrdup (line_buf);
16348
16349 maskcnt++;
16350 }
16351
16352 myfree (line_buf);
16353
16354 fclose (mask_fp);
16355
16356 mask_from_file = 1;
16357 }
16358 else
16359 {
16360 maskcnt = 1;
16361
16362 masks[maskcnt - 1] = mystrdup (mask);
16363 }
16364 }
16365
16366 // base
16367
16368 int wls_left = myargc - (optind + 2);
16369
16370 for (int i = 0; i < wls_left; i++)
16371 {
16372 char *filename = myargv[optind + 1 + i];
16373
16374 struct stat file_stat;
16375
16376 if (stat (filename, &file_stat) == -1)
16377 {
16378 log_error ("ERROR: %s: %s", filename, strerror (errno));
16379
16380 return (-1);
16381 }
16382
16383 uint is_dir = S_ISDIR (file_stat.st_mode);
16384
16385 if (is_dir == 0)
16386 {
16387 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16388
16389 dictcnt++;
16390
16391 dictfiles[dictcnt - 1] = filename;
16392 }
16393 else
16394 {
16395 // do not allow --keyspace w/ a directory
16396
16397 if (keyspace == 1)
16398 {
16399 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16400
16401 return (-1);
16402 }
16403
16404 char **dictionary_files = NULL;
16405
16406 dictionary_files = scan_directory (filename);
16407
16408 if (dictionary_files != NULL)
16409 {
16410 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16411
16412 for (int d = 0; dictionary_files[d] != NULL; d++)
16413 {
16414 char *l1_filename = dictionary_files[d];
16415
16416 struct stat l1_stat;
16417
16418 if (stat (l1_filename, &l1_stat) == -1)
16419 {
16420 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16421
16422 return (-1);
16423 }
16424
16425 if (S_ISREG (l1_stat.st_mode))
16426 {
16427 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16428
16429 dictcnt++;
16430
16431 dictfiles[dictcnt - 1] = strdup (l1_filename);
16432 }
16433 }
16434 }
16435
16436 local_free (dictionary_files);
16437 }
16438 }
16439
16440 if (dictcnt < 1)
16441 {
16442 log_error ("ERROR: No usable dictionary file found.");
16443
16444 return (-1);
16445 }
16446
16447 if (increment)
16448 {
16449 maskcnt = 0;
16450
16451 uint mask_min = increment_min; // we can't reject smaller masks here
16452 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16453
16454 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16455 {
16456 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16457
16458 if (cur_mask == NULL) break;
16459
16460 masks[maskcnt] = cur_mask;
16461
16462 maskcnt++;
16463
16464 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16465 }
16466 }
16467 }
16468 else if (attack_mode == ATTACK_MODE_HYBRID2)
16469 {
16470 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16471
16472 // display
16473
16474 char *mask = myargv[optind + 1 + 0];
16475
16476 maskcnt = 0;
16477
16478 masks = (char **) mymalloc (1 * sizeof (char *));
16479
16480 // mod
16481
16482 struct stat file_stat;
16483
16484 if (stat (mask, &file_stat) == -1)
16485 {
16486 maskcnt = 1;
16487
16488 masks[maskcnt - 1] = mystrdup (mask);
16489 }
16490 else
16491 {
16492 uint is_file = S_ISREG (file_stat.st_mode);
16493
16494 if (is_file == 1)
16495 {
16496 FILE *mask_fp;
16497
16498 if ((mask_fp = fopen (mask, "r")) == NULL)
16499 {
16500 log_error ("ERROR: %s: %s", mask, strerror (errno));
16501
16502 return (-1);
16503 }
16504
16505 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16506
16507 uint masks_avail = 1;
16508
16509 while (!feof (mask_fp))
16510 {
16511 memset (line_buf, 0, HCBUFSIZ);
16512
16513 int line_len = fgetl (mask_fp, line_buf);
16514
16515 if (line_len == 0) continue;
16516
16517 if (line_buf[0] == '#') continue;
16518
16519 if (masks_avail == maskcnt)
16520 {
16521 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16522
16523 masks_avail += INCR_MASKS;
16524 }
16525
16526 masks[maskcnt] = mystrdup (line_buf);
16527
16528 maskcnt++;
16529 }
16530
16531 myfree (line_buf);
16532
16533 fclose (mask_fp);
16534
16535 mask_from_file = 1;
16536 }
16537 else
16538 {
16539 maskcnt = 1;
16540
16541 masks[maskcnt - 1] = mystrdup (mask);
16542 }
16543 }
16544
16545 // base
16546
16547 int wls_left = myargc - (optind + 2);
16548
16549 for (int i = 0; i < wls_left; i++)
16550 {
16551 char *filename = myargv[optind + 2 + i];
16552
16553 struct stat file_stat;
16554
16555 if (stat (filename, &file_stat) == -1)
16556 {
16557 log_error ("ERROR: %s: %s", filename, strerror (errno));
16558
16559 return (-1);
16560 }
16561
16562 uint is_dir = S_ISDIR (file_stat.st_mode);
16563
16564 if (is_dir == 0)
16565 {
16566 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16567
16568 dictcnt++;
16569
16570 dictfiles[dictcnt - 1] = filename;
16571 }
16572 else
16573 {
16574 // do not allow --keyspace w/ a directory
16575
16576 if (keyspace == 1)
16577 {
16578 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16579
16580 return (-1);
16581 }
16582
16583 char **dictionary_files = NULL;
16584
16585 dictionary_files = scan_directory (filename);
16586
16587 if (dictionary_files != NULL)
16588 {
16589 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16590
16591 for (int d = 0; dictionary_files[d] != NULL; d++)
16592 {
16593 char *l1_filename = dictionary_files[d];
16594
16595 struct stat l1_stat;
16596
16597 if (stat (l1_filename, &l1_stat) == -1)
16598 {
16599 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16600
16601 return (-1);
16602 }
16603
16604 if (S_ISREG (l1_stat.st_mode))
16605 {
16606 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16607
16608 dictcnt++;
16609
16610 dictfiles[dictcnt - 1] = strdup (l1_filename);
16611 }
16612 }
16613 }
16614
16615 local_free (dictionary_files);
16616 }
16617 }
16618
16619 if (dictcnt < 1)
16620 {
16621 log_error ("ERROR: No usable dictionary file found.");
16622
16623 return (-1);
16624 }
16625
16626 if (increment)
16627 {
16628 maskcnt = 0;
16629
16630 uint mask_min = increment_min; // we can't reject smaller masks here
16631 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16632
16633 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16634 {
16635 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16636
16637 if (cur_mask == NULL) break;
16638
16639 masks[maskcnt] = cur_mask;
16640
16641 maskcnt++;
16642
16643 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16644 }
16645 }
16646 }
16647
16648 data.pw_min = pw_min;
16649 data.pw_max = pw_max;
16650
16651 /**
16652 * weak hash check
16653 */
16654
16655 if (weak_hash_threshold >= salts_cnt)
16656 {
16657 hc_device_param_t *device_param = NULL;
16658
16659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16660 {
16661 device_param = &data.devices_param[device_id];
16662
16663 if (device_param->skipped) continue;
16664
16665 break;
16666 }
16667
16668 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16669
16670 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16671 {
16672 weak_hash_check (device_param, salt_pos);
16673 }
16674
16675 // Display hack, guarantee that there is at least one \r before real start
16676
16677 //if (data.quiet == 0) log_info ("");
16678 }
16679
16680 /**
16681 * status and monitor threads
16682 */
16683
16684 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16685
16686 hc_thread_t i_thread = 0;
16687
16688 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16689 {
16690 hc_thread_create (i_thread, thread_keypress, &benchmark);
16691 }
16692
16693 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16694
16695 uint ni_threads_cnt = 0;
16696
16697 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16698
16699 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16700
16701 ni_threads_cnt++;
16702
16703 /**
16704 * Outfile remove
16705 */
16706
16707 if (keyspace == 0)
16708 {
16709 if (outfile_check_timer != 0)
16710 {
16711 if (data.outfile_check_directory != NULL)
16712 {
16713 if ((hash_mode != 5200) &&
16714 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16715 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16716 (hash_mode != 9000))
16717 {
16718 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16719
16720 ni_threads_cnt++;
16721 }
16722 else
16723 {
16724 outfile_check_timer = 0;
16725 }
16726 }
16727 else
16728 {
16729 outfile_check_timer = 0;
16730 }
16731 }
16732 }
16733
16734 /**
16735 * Inform the user if we got some hashes remove because of the pot file remove feature
16736 */
16737
16738 if (data.quiet == 0)
16739 {
16740 if (potfile_remove_cracks > 0)
16741 {
16742 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16743 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16744 }
16745 }
16746
16747 data.outfile_check_timer = outfile_check_timer;
16748
16749 /**
16750 * main loop
16751 */
16752
16753 char **induction_dictionaries = NULL;
16754
16755 int induction_dictionaries_cnt = 0;
16756
16757 hcstat_table_t *root_table_buf = NULL;
16758 hcstat_table_t *markov_table_buf = NULL;
16759
16760 uint initial_restore_done = 0;
16761
16762 data.maskcnt = maskcnt;
16763
16764 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16765 {
16766 if (data.devices_status == STATUS_CRACKED) break;
16767
16768 data.devices_status = STATUS_INIT;
16769
16770 if (maskpos > rd->maskpos)
16771 {
16772 rd->dictpos = 0;
16773 }
16774
16775 rd->maskpos = maskpos;
16776 data.maskpos = maskpos;
16777
16778 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16779 {
16780 char *mask = masks[maskpos];
16781
16782 if (mask_from_file == 1)
16783 {
16784 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16785
16786 char *str_ptr;
16787 uint str_pos;
16788
16789 uint mask_offset = 0;
16790
16791 uint separator_cnt;
16792
16793 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16794 {
16795 str_ptr = strstr (mask + mask_offset, ",");
16796
16797 if (str_ptr == NULL) break;
16798
16799 str_pos = str_ptr - mask;
16800
16801 // escaped separator, i.e. "\,"
16802
16803 if (str_pos > 0)
16804 {
16805 if (mask[str_pos - 1] == '\\')
16806 {
16807 separator_cnt --;
16808
16809 mask_offset = str_pos + 1;
16810
16811 continue;
16812 }
16813 }
16814
16815 // reset the offset
16816
16817 mask_offset = 0;
16818
16819 mask[str_pos] = '\0';
16820
16821 switch (separator_cnt)
16822 {
16823 case 0:
16824 mp_reset_usr (mp_usr, 0);
16825
16826 custom_charset_1 = mask;
16827 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16828 break;
16829
16830 case 1:
16831 mp_reset_usr (mp_usr, 1);
16832
16833 custom_charset_2 = mask;
16834 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16835 break;
16836
16837 case 2:
16838 mp_reset_usr (mp_usr, 2);
16839
16840 custom_charset_3 = mask;
16841 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16842 break;
16843
16844 case 3:
16845 mp_reset_usr (mp_usr, 3);
16846
16847 custom_charset_4 = mask;
16848 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16849 break;
16850 }
16851
16852 mask = mask + str_pos + 1;
16853 }
16854 }
16855
16856 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16857 {
16858 if (maskpos > 0)
16859 {
16860 local_free (css_buf);
16861 local_free (data.root_css_buf);
16862 local_free (data.markov_css_buf);
16863
16864 local_free (masks[maskpos - 1]);
16865 }
16866
16867 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16868
16869 data.mask = mask;
16870 data.css_cnt = css_cnt;
16871 data.css_buf = css_buf;
16872
16873 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16874
16875 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16876
16877 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16878 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16879
16880 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16881
16882 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16883
16884 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16885 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16886
16887 data.root_css_buf = root_css_buf;
16888 data.markov_css_buf = markov_css_buf;
16889
16890 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16891
16892 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16893
16894 local_free (root_table_buf);
16895 local_free (markov_table_buf);
16896
16897 // args
16898
16899 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16900 {
16901 hc_device_param_t *device_param = &data.devices_param[device_id];
16902
16903 if (device_param->skipped) continue;
16904
16905 device_param->kernel_params_mp[0] = &device_param->d_combs;
16906 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16907 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16908
16909 device_param->kernel_params_mp_buf64[3] = 0;
16910 device_param->kernel_params_mp_buf32[4] = css_cnt;
16911 device_param->kernel_params_mp_buf32[5] = 0;
16912 device_param->kernel_params_mp_buf32[6] = 0;
16913 device_param->kernel_params_mp_buf32[7] = 0;
16914
16915 if (attack_mode == ATTACK_MODE_HYBRID1)
16916 {
16917 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16918 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16919 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16920 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16921 }
16922 else if (attack_mode == ATTACK_MODE_HYBRID2)
16923 {
16924 device_param->kernel_params_mp_buf32[5] = 0;
16925 device_param->kernel_params_mp_buf32[6] = 0;
16926 device_param->kernel_params_mp_buf32[7] = 0;
16927 }
16928
16929 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]);
16930 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]);
16931 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]);
16932
16933 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);
16934 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);
16935 }
16936 }
16937 else if (attack_mode == ATTACK_MODE_BF)
16938 {
16939 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16940
16941 if (increment)
16942 {
16943 for (uint i = 0; i < dictcnt; i++)
16944 {
16945 local_free (dictfiles[i]);
16946 }
16947
16948 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16949 {
16950 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16951
16952 if (l1_filename == NULL) break;
16953
16954 dictcnt++;
16955
16956 dictfiles[dictcnt - 1] = l1_filename;
16957 }
16958 }
16959 else
16960 {
16961 dictcnt++;
16962
16963 dictfiles[dictcnt - 1] = mask;
16964 }
16965
16966 if (dictcnt == 0)
16967 {
16968 log_error ("ERROR: Mask is too small");
16969
16970 return (-1);
16971 }
16972 }
16973 }
16974
16975 free (induction_dictionaries);
16976
16977 // induction_dictionaries_cnt = 0; // implied
16978
16979 if (attack_mode != ATTACK_MODE_BF)
16980 {
16981 if (keyspace == 0)
16982 {
16983 induction_dictionaries = scan_directory (induction_directory);
16984
16985 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16986 }
16987 }
16988
16989 if (induction_dictionaries_cnt)
16990 {
16991 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16992 }
16993
16994 /**
16995 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16996 */
16997 if (keyspace == 1)
16998 {
16999 if ((maskcnt > 1) || (dictcnt > 1))
17000 {
17001 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17002
17003 return (-1);
17004 }
17005 }
17006
17007 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17008 {
17009 char *subid = logfile_generate_subid ();
17010
17011 data.subid = subid;
17012
17013 logfile_sub_msg ("START");
17014
17015 data.devices_status = STATUS_INIT;
17016
17017 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17018 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17019 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17020
17021 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17022
17023 data.cpt_pos = 0;
17024
17025 data.cpt_start = time (NULL);
17026
17027 data.cpt_total = 0;
17028
17029 if (data.restore == 0)
17030 {
17031 rd->words_cur = skip;
17032
17033 skip = 0;
17034
17035 data.skip = 0;
17036 }
17037
17038 data.ms_paused = 0;
17039
17040 data.kernel_power_div = 0;
17041
17042 data.words_cur = rd->words_cur;
17043
17044 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17045 {
17046 hc_device_param_t *device_param = &data.devices_param[device_id];
17047
17048 if (device_param->skipped) continue;
17049
17050 device_param->speed_pos = 0;
17051
17052 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17053 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17054
17055 device_param->exec_pos = 0;
17056
17057 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17058
17059 device_param->outerloop_pos = 0;
17060 device_param->outerloop_left = 0;
17061 device_param->innerloop_pos = 0;
17062 device_param->innerloop_left = 0;
17063
17064 // some more resets:
17065
17066 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17067
17068 device_param->pws_cnt = 0;
17069
17070 device_param->words_off = 0;
17071 device_param->words_done = 0;
17072 }
17073
17074 // figure out some workload
17075
17076 if (attack_mode == ATTACK_MODE_STRAIGHT)
17077 {
17078 if (data.wordlist_mode == WL_MODE_FILE)
17079 {
17080 char *dictfile = NULL;
17081
17082 if (induction_dictionaries_cnt)
17083 {
17084 dictfile = induction_dictionaries[0];
17085 }
17086 else
17087 {
17088 dictfile = dictfiles[dictpos];
17089 }
17090
17091 data.dictfile = dictfile;
17092
17093 logfile_sub_string (dictfile);
17094
17095 for (uint i = 0; i < rp_files_cnt; i++)
17096 {
17097 logfile_sub_var_string ("rulefile", rp_files[i]);
17098 }
17099
17100 FILE *fd2 = fopen (dictfile, "rb");
17101
17102 if (fd2 == NULL)
17103 {
17104 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17105
17106 return (-1);
17107 }
17108
17109 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17110
17111 fclose (fd2);
17112
17113 if (data.words_cnt == 0)
17114 {
17115 if (data.devices_status == STATUS_CRACKED) break;
17116 if (data.devices_status == STATUS_ABORTED) break;
17117
17118 dictpos++;
17119
17120 continue;
17121 }
17122 }
17123 }
17124 else if (attack_mode == ATTACK_MODE_COMBI)
17125 {
17126 char *dictfile = data.dictfile;
17127 char *dictfile2 = data.dictfile2;
17128
17129 logfile_sub_string (dictfile);
17130 logfile_sub_string (dictfile2);
17131
17132 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17133 {
17134 FILE *fd2 = fopen (dictfile, "rb");
17135
17136 if (fd2 == NULL)
17137 {
17138 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17139
17140 return (-1);
17141 }
17142
17143 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17144
17145 fclose (fd2);
17146 }
17147 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17148 {
17149 FILE *fd2 = fopen (dictfile2, "rb");
17150
17151 if (fd2 == NULL)
17152 {
17153 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17154
17155 return (-1);
17156 }
17157
17158 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17159
17160 fclose (fd2);
17161 }
17162
17163 if (data.words_cnt == 0)
17164 {
17165 if (data.devices_status == STATUS_CRACKED) break;
17166 if (data.devices_status == STATUS_ABORTED) break;
17167
17168 dictpos++;
17169
17170 continue;
17171 }
17172 }
17173 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17174 {
17175 char *dictfile = NULL;
17176
17177 if (induction_dictionaries_cnt)
17178 {
17179 dictfile = induction_dictionaries[0];
17180 }
17181 else
17182 {
17183 dictfile = dictfiles[dictpos];
17184 }
17185
17186 data.dictfile = dictfile;
17187
17188 char *mask = data.mask;
17189
17190 logfile_sub_string (dictfile);
17191 logfile_sub_string (mask);
17192
17193 FILE *fd2 = fopen (dictfile, "rb");
17194
17195 if (fd2 == NULL)
17196 {
17197 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17198
17199 return (-1);
17200 }
17201
17202 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17203
17204 fclose (fd2);
17205
17206 if (data.words_cnt == 0)
17207 {
17208 if (data.devices_status == STATUS_CRACKED) break;
17209 if (data.devices_status == STATUS_ABORTED) break;
17210
17211 dictpos++;
17212
17213 continue;
17214 }
17215 }
17216 else if (attack_mode == ATTACK_MODE_BF)
17217 {
17218 local_free (css_buf);
17219 local_free (data.root_css_buf);
17220 local_free (data.markov_css_buf);
17221
17222 char *mask = dictfiles[dictpos];
17223
17224 logfile_sub_string (mask);
17225
17226 // base
17227
17228 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17229
17230 if (opts_type & OPTS_TYPE_PT_UNICODE)
17231 {
17232 uint css_cnt_unicode = css_cnt * 2;
17233
17234 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17235
17236 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17237 {
17238 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17239
17240 css_buf_unicode[j + 1].cs_buf[0] = 0;
17241 css_buf_unicode[j + 1].cs_len = 1;
17242 }
17243
17244 free (css_buf);
17245
17246 css_buf = css_buf_unicode;
17247 css_cnt = css_cnt_unicode;
17248 }
17249
17250 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17251
17252 uint mask_min = pw_min;
17253 uint mask_max = pw_max;
17254
17255 if (opts_type & OPTS_TYPE_PT_UNICODE)
17256 {
17257 mask_min *= 2;
17258 mask_max *= 2;
17259 }
17260
17261 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17262 {
17263 if (css_cnt < mask_min)
17264 {
17265 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17266 }
17267
17268 if (css_cnt > mask_max)
17269 {
17270 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17271 }
17272
17273 // skip to next mask
17274
17275 dictpos++;
17276
17277 rd->dictpos = dictpos;
17278
17279 logfile_sub_msg ("STOP");
17280
17281 continue;
17282 }
17283
17284 uint save_css_cnt = css_cnt;
17285
17286 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17287 {
17288 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17289 {
17290 uint salt_len = (uint) data.salts_buf[0].salt_len;
17291 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17292
17293 uint css_cnt_salt = css_cnt + salt_len;
17294
17295 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17296
17297 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17298
17299 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17300 {
17301 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17302 css_buf_salt[j].cs_len = 1;
17303 }
17304
17305 free (css_buf);
17306
17307 css_buf = css_buf_salt;
17308 css_cnt = css_cnt_salt;
17309 }
17310 }
17311
17312 data.mask = mask;
17313 data.css_cnt = css_cnt;
17314 data.css_buf = css_buf;
17315
17316 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17317
17318 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17319
17320 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17321
17322 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17323 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17324
17325 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17326
17327 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17328
17329 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17330 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17331
17332 data.root_css_buf = root_css_buf;
17333 data.markov_css_buf = markov_css_buf;
17334
17335 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17336
17337 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17338
17339 local_free (root_table_buf);
17340 local_free (markov_table_buf);
17341
17342 // copy + args
17343
17344 uint css_cnt_l = css_cnt;
17345 uint css_cnt_r;
17346
17347 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17348 {
17349 if (save_css_cnt < 6)
17350 {
17351 css_cnt_r = 1;
17352 }
17353 else if (save_css_cnt == 6)
17354 {
17355 css_cnt_r = 2;
17356 }
17357 else
17358 {
17359 if (opts_type & OPTS_TYPE_PT_UNICODE)
17360 {
17361 if (save_css_cnt == 8 || save_css_cnt == 10)
17362 {
17363 css_cnt_r = 2;
17364 }
17365 else
17366 {
17367 css_cnt_r = 4;
17368 }
17369 }
17370 else
17371 {
17372 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17373 {
17374 css_cnt_r = 3;
17375 }
17376 else
17377 {
17378 css_cnt_r = 4;
17379 }
17380 }
17381 }
17382 }
17383 else
17384 {
17385 css_cnt_r = 1;
17386
17387 /* unfinished code?
17388 int sum = css_buf[css_cnt_r - 1].cs_len;
17389
17390 for (uint i = 1; i < 4 && i < css_cnt; i++)
17391 {
17392 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17393
17394 css_cnt_r++;
17395
17396 sum *= css_buf[css_cnt_r - 1].cs_len;
17397 }
17398 */
17399 }
17400
17401 css_cnt_l -= css_cnt_r;
17402
17403 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17404
17405 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17406 {
17407 hc_device_param_t *device_param = &data.devices_param[device_id];
17408
17409 if (device_param->skipped) continue;
17410
17411 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17412 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17413 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17414
17415 device_param->kernel_params_mp_l_buf64[3] = 0;
17416 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17417 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17418 device_param->kernel_params_mp_l_buf32[6] = 0;
17419 device_param->kernel_params_mp_l_buf32[7] = 0;
17420 device_param->kernel_params_mp_l_buf32[8] = 0;
17421
17422 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17423 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17424 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17425 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17426
17427 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17428 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17429 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17430
17431 device_param->kernel_params_mp_r_buf64[3] = 0;
17432 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17433 device_param->kernel_params_mp_r_buf32[5] = 0;
17434 device_param->kernel_params_mp_r_buf32[6] = 0;
17435 device_param->kernel_params_mp_r_buf32[7] = 0;
17436
17437 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]);
17438 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]);
17439 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]);
17440
17441 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]);
17442 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]);
17443 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]);
17444
17445 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);
17446 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);
17447 }
17448 }
17449
17450 u64 words_base = data.words_cnt;
17451
17452 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17453 {
17454 if (data.kernel_rules_cnt)
17455 {
17456 words_base /= data.kernel_rules_cnt;
17457 }
17458 }
17459 else if (data.attack_kern == ATTACK_KERN_COMBI)
17460 {
17461 if (data.combs_cnt)
17462 {
17463 words_base /= data.combs_cnt;
17464 }
17465 }
17466 else if (data.attack_kern == ATTACK_KERN_BF)
17467 {
17468 if (data.bfs_cnt)
17469 {
17470 words_base /= data.bfs_cnt;
17471 }
17472 }
17473
17474 data.words_base = words_base;
17475
17476 if (keyspace == 1)
17477 {
17478 log_info ("%llu", (unsigned long long int) words_base);
17479
17480 return (0);
17481 }
17482
17483 if (data.words_cur > data.words_base)
17484 {
17485 log_error ("ERROR: restore value greater keyspace");
17486
17487 return (-1);
17488 }
17489
17490 if (data.words_cur)
17491 {
17492 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17493 {
17494 for (uint i = 0; i < data.salts_cnt; i++)
17495 {
17496 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17497 }
17498 }
17499 else if (data.attack_kern == ATTACK_KERN_COMBI)
17500 {
17501 for (uint i = 0; i < data.salts_cnt; i++)
17502 {
17503 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17504 }
17505 }
17506 else if (data.attack_kern == ATTACK_KERN_BF)
17507 {
17508 for (uint i = 0; i < data.salts_cnt; i++)
17509 {
17510 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17511 }
17512 }
17513 }
17514
17515 /*
17516 * Update loopback file
17517 */
17518
17519 if (loopback == 1)
17520 {
17521 time_t now;
17522
17523 time (&now);
17524
17525 uint random_num = get_random_num (0, 9999);
17526
17527 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17528
17529 data.loopback_file = loopback_file;
17530 }
17531
17532 /*
17533 * Update dictionary statistic
17534 */
17535
17536 if (keyspace == 0)
17537 {
17538 dictstat_fp = fopen (dictstat, "wb");
17539
17540 if (dictstat_fp)
17541 {
17542 lock_file (dictstat_fp);
17543
17544 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17545
17546 fclose (dictstat_fp);
17547 }
17548 }
17549
17550 data.devices_status = STATUS_RUNNING;
17551
17552 if (initial_restore_done == 0)
17553 {
17554 if (data.restore_disable == 0) cycle_restore ();
17555
17556 initial_restore_done = 1;
17557 }
17558
17559 hc_timer_set (&data.timer_running);
17560
17561 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17562 {
17563 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17564 {
17565 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17566 if (quiet == 0) fflush (stdout);
17567 }
17568 }
17569 else if (wordlist_mode == WL_MODE_STDIN)
17570 {
17571 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17572 if (data.quiet == 0) log_info ("");
17573 }
17574
17575 /**
17576 * create autotune threads
17577 */
17578
17579 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17580
17581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17582 {
17583 hc_device_param_t *device_param = &devices_param[device_id];
17584
17585 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17586 }
17587
17588 hc_thread_wait (data.devices_cnt, c_threads);
17589
17590 /*
17591 * Inform user about possible slow speeds
17592 */
17593
17594 uint kernel_power_all = 0;
17595
17596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17597 {
17598 hc_device_param_t *device_param = &devices_param[device_id];
17599
17600 kernel_power_all += device_param->kernel_power;
17601 }
17602
17603 data.kernel_power_all = kernel_power_all;
17604
17605 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17606 {
17607 if (data.words_base < kernel_power_all)
17608 {
17609 if (quiet == 0)
17610 {
17611 log_info ("ATTENTION!");
17612 log_info (" The wordlist or mask you are using is too small.");
17613 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17614 log_info (" The cracking speed will drop.");
17615 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17616 log_info ("");
17617 }
17618 }
17619 }
17620
17621 /**
17622 * create cracker threads
17623 */
17624
17625 time_t runtime_start;
17626
17627 time (&runtime_start);
17628
17629 data.runtime_start = runtime_start;
17630
17631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17632 {
17633 hc_device_param_t *device_param = &devices_param[device_id];
17634
17635 if (wordlist_mode == WL_MODE_STDIN)
17636 {
17637 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17638 }
17639 else
17640 {
17641 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17642 }
17643 }
17644
17645 hc_thread_wait (data.devices_cnt, c_threads);
17646
17647 local_free (c_threads);
17648
17649 data.restore = 0;
17650
17651 // finalize task
17652
17653 logfile_sub_var_uint ("status-after-work", data.devices_status);
17654
17655 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17656
17657 if (data.devices_status == STATUS_CRACKED) break;
17658 if (data.devices_status == STATUS_ABORTED) break;
17659
17660 if (data.devices_status == STATUS_BYPASS)
17661 {
17662 data.devices_status = STATUS_RUNNING;
17663 }
17664
17665 if (induction_dictionaries_cnt)
17666 {
17667 unlink (induction_dictionaries[0]);
17668 }
17669
17670 free (induction_dictionaries);
17671
17672 if (attack_mode != ATTACK_MODE_BF)
17673 {
17674 induction_dictionaries = scan_directory (induction_directory);
17675
17676 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17677 }
17678
17679 if (benchmark == 0)
17680 {
17681 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17682 {
17683 if (quiet == 0) clear_prompt ();
17684
17685 if (quiet == 0) log_info ("");
17686
17687 if (status == 1)
17688 {
17689 status_display ();
17690 }
17691 else
17692 {
17693 if (quiet == 0) status_display ();
17694 }
17695
17696 if (quiet == 0) log_info ("");
17697 }
17698 }
17699
17700 if (attack_mode == ATTACK_MODE_BF)
17701 {
17702 dictpos++;
17703
17704 rd->dictpos = dictpos;
17705 }
17706 else
17707 {
17708 if (induction_dictionaries_cnt)
17709 {
17710 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17711 }
17712 else
17713 {
17714 dictpos++;
17715
17716 rd->dictpos = dictpos;
17717 }
17718 }
17719
17720 time_t runtime_stop;
17721
17722 time (&runtime_stop);
17723
17724 data.runtime_stop = runtime_stop;
17725
17726 logfile_sub_uint (runtime_start);
17727 logfile_sub_uint (runtime_stop);
17728
17729 logfile_sub_msg ("STOP");
17730
17731 global_free (subid);
17732 }
17733
17734 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17735
17736 if (data.devices_status == STATUS_CRACKED) break;
17737 if (data.devices_status == STATUS_ABORTED) break;
17738 if (data.devices_status == STATUS_QUIT) break;
17739
17740 if (data.devices_status == STATUS_BYPASS)
17741 {
17742 data.devices_status = STATUS_RUNNING;
17743 }
17744 }
17745
17746 // 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
17747
17748 if (attack_mode == ATTACK_MODE_STRAIGHT)
17749 {
17750 if (data.wordlist_mode == WL_MODE_FILE)
17751 {
17752 if (data.dictfile == NULL)
17753 {
17754 if (dictfiles != NULL)
17755 {
17756 data.dictfile = dictfiles[0];
17757
17758 hc_timer_set (&data.timer_running);
17759 }
17760 }
17761 }
17762 }
17763 // NOTE: combi is okay because it is already set beforehand
17764 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17765 {
17766 if (data.dictfile == NULL)
17767 {
17768 if (dictfiles != NULL)
17769 {
17770 hc_timer_set (&data.timer_running);
17771
17772 data.dictfile = dictfiles[0];
17773 }
17774 }
17775 }
17776 else if (attack_mode == ATTACK_MODE_BF)
17777 {
17778 if (data.mask == NULL)
17779 {
17780 hc_timer_set (&data.timer_running);
17781
17782 data.mask = masks[0];
17783 }
17784 }
17785
17786 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17787 {
17788 data.devices_status = STATUS_EXHAUSTED;
17789 }
17790
17791 // if cracked / aborted remove last induction dictionary
17792
17793 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17794 {
17795 struct stat induct_stat;
17796
17797 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17798 {
17799 unlink (induction_dictionaries[file_pos]);
17800 }
17801 }
17802
17803 // wait for non-interactive threads
17804
17805 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17806 {
17807 hc_thread_wait (1, &ni_threads[thread_idx]);
17808 }
17809
17810 local_free (ni_threads);
17811
17812 // wait for interactive threads
17813
17814 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17815 {
17816 hc_thread_wait (1, &i_thread);
17817 }
17818
17819 // we dont need restore file anymore
17820 if (data.restore_disable == 0)
17821 {
17822 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17823 {
17824 unlink (eff_restore_file);
17825 unlink (new_restore_file);
17826 }
17827 else
17828 {
17829 cycle_restore ();
17830 }
17831 }
17832
17833 // finally save left hashes
17834
17835 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17836 {
17837 save_hash ();
17838 }
17839
17840 /**
17841 * Clean up
17842 */
17843
17844 if (benchmark == 1)
17845 {
17846 status_benchmark ();
17847
17848 if (machine_readable == 0)
17849 {
17850 log_info ("");
17851 }
17852 }
17853 else
17854 {
17855 if (quiet == 0) clear_prompt ();
17856
17857 if (quiet == 0) log_info ("");
17858
17859 if (status == 1)
17860 {
17861 status_display ();
17862 }
17863 else
17864 {
17865 if (quiet == 0) status_display ();
17866 }
17867
17868 if (quiet == 0) log_info ("");
17869 }
17870
17871 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17872 {
17873 hc_device_param_t *device_param = &data.devices_param[device_id];
17874
17875 if (device_param->skipped) continue;
17876
17877 local_free (device_param->combs_buf);
17878
17879 local_free (device_param->hooks_buf);
17880
17881 local_free (device_param->device_name);
17882
17883 local_free (device_param->device_name_chksum);
17884
17885 local_free (device_param->device_version);
17886
17887 local_free (device_param->driver_version);
17888
17889 if (device_param->pws_buf) myfree (device_param->pws_buf);
17890 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17891 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17892 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17893 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17894 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17895 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17896 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17897 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17898 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17899 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17900 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17901 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17902 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17903 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17904 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17905 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17906 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17907 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17908 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17909 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17910 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17911 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17912 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17913 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17914 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17915 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17916 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17917 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17918
17919 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17920 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17921 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17922 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17923 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17924 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17925 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17926 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17927 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17928 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17929 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17930
17931 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17932 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17933 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17934
17935 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17936 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17937 }
17938
17939 // reset default fan speed
17940
17941 #ifdef HAVE_HWMON
17942 if (gpu_temp_disable == 0)
17943 {
17944 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17945 {
17946 hc_thread_mutex_lock (mux_adl);
17947
17948 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17949 {
17950 hc_device_param_t *device_param = &data.devices_param[device_id];
17951
17952 if (device_param->skipped) continue;
17953
17954 if (data.hm_device[device_id].fan_set_supported == 1)
17955 {
17956 int fanspeed = temp_retain_fanspeed_value[device_id];
17957 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17958
17959 if (fanpolicy == 1)
17960 {
17961 int rc = -1;
17962
17963 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17964 {
17965 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17966 }
17967 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17968 {
17969
17970 }
17971
17972 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17973 }
17974 }
17975 }
17976
17977 hc_thread_mutex_unlock (mux_adl);
17978 }
17979 }
17980
17981 // reset power tuning
17982
17983 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17984 {
17985 hc_thread_mutex_lock (mux_adl);
17986
17987 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17988 {
17989 hc_device_param_t *device_param = &data.devices_param[device_id];
17990
17991 if (device_param->skipped) continue;
17992
17993 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17994 {
17995 if (data.hm_device[device_id].od_version == 6)
17996 {
17997 // check powertune capabilities first, if not available then skip device
17998
17999 int powertune_supported = 0;
18000
18001 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK)
18002 {
18003 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18004
18005 return (-1);
18006 }
18007
18008 if (powertune_supported != 0)
18009 {
18010 // powercontrol settings
18011
18012 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, od_power_control_status[device_id])) != ADL_OK)
18013 {
18014 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18015
18016 return (-1);
18017 }
18018
18019 // clocks
18020
18021 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18022
18023 performance_state->iNumberOfPerformanceLevels = 2;
18024
18025 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18026 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18027 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18028 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18029
18030 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18031 {
18032 log_info ("ERROR: Failed to restore ADL performance state");
18033
18034 return (-1);
18035 }
18036
18037 local_free (performance_state);
18038 }
18039 }
18040 }
18041
18042 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18043 {
18044 unsigned int limit = nvml_power_limit[device_id];
18045
18046 if (limit > 0)
18047 {
18048 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, limit);
18049 }
18050 }
18051 }
18052
18053 hc_thread_mutex_unlock (mux_adl);
18054 }
18055
18056 if (gpu_temp_disable == 0)
18057 {
18058 if (data.hm_nvml)
18059 {
18060 hm_NVML_nvmlShutdown (data.hm_nvml);
18061
18062 nvml_close (data.hm_nvml);
18063
18064 data.hm_nvml = NULL;
18065 }
18066
18067 if (data.hm_adl)
18068 {
18069 hm_ADL_Main_Control_Destroy (data.hm_adl);
18070
18071 adl_close (data.hm_adl);
18072
18073 data.hm_adl = NULL;
18074 }
18075 }
18076 #endif // HAVE_HWMON
18077
18078 // free memory
18079
18080 local_free (masks);
18081
18082 local_free (dictstat_base);
18083
18084 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18085 {
18086 pot_t *pot_ptr = &pot[pot_pos];
18087
18088 hash_t *hash = &pot_ptr->hash;
18089
18090 local_free (hash->digest);
18091
18092 if (isSalted)
18093 {
18094 local_free (hash->salt);
18095 }
18096 }
18097
18098 local_free (pot);
18099
18100 local_free (all_kernel_rules_cnt);
18101 local_free (all_kernel_rules_buf);
18102
18103 local_free (wl_data->buf);
18104 local_free (wl_data);
18105
18106 local_free (bitmap_s1_a);
18107 local_free (bitmap_s1_b);
18108 local_free (bitmap_s1_c);
18109 local_free (bitmap_s1_d);
18110 local_free (bitmap_s2_a);
18111 local_free (bitmap_s2_b);
18112 local_free (bitmap_s2_c);
18113 local_free (bitmap_s2_d);
18114
18115 #ifdef HAVE_HWMON
18116 local_free (temp_retain_fanspeed_value);
18117 local_free (od_clock_mem_status);
18118 local_free (od_power_control_status);
18119 local_free (nvml_power_limit);
18120 #endif
18121
18122 global_free (devices_param);
18123
18124 global_free (kernel_rules_buf);
18125
18126 global_free (root_css_buf);
18127 global_free (markov_css_buf);
18128
18129 global_free (digests_buf);
18130 global_free (digests_shown);
18131 global_free (digests_shown_tmp);
18132
18133 global_free (salts_buf);
18134 global_free (salts_shown);
18135
18136 global_free (esalts_buf);
18137
18138 global_free (words_progress_done);
18139 global_free (words_progress_rejected);
18140 global_free (words_progress_restored);
18141
18142 if (pot_fp) fclose (pot_fp);
18143
18144 if (data.devices_status == STATUS_QUIT) break;
18145 }
18146
18147 // destroy others mutex
18148
18149 hc_thread_mutex_delete (mux_dispatcher);
18150 hc_thread_mutex_delete (mux_counter);
18151 hc_thread_mutex_delete (mux_display);
18152 hc_thread_mutex_delete (mux_adl);
18153
18154 // free memory
18155
18156 local_free (eff_restore_file);
18157 local_free (new_restore_file);
18158
18159 local_free (rd);
18160
18161 // tuning db
18162
18163 tuning_db_destroy (tuning_db);
18164
18165 // loopback
18166
18167 local_free (loopback_file);
18168
18169 if (loopback == 1) unlink (loopback_file);
18170
18171 // induction directory
18172
18173 if (induction_dir == NULL)
18174 {
18175 if (attack_mode != ATTACK_MODE_BF)
18176 {
18177 if (rmdir (induction_directory) == -1)
18178 {
18179 if (errno == ENOENT)
18180 {
18181 // good, we can ignore
18182 }
18183 else if (errno == ENOTEMPTY)
18184 {
18185 // good, we can ignore
18186 }
18187 else
18188 {
18189 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18190
18191 return (-1);
18192 }
18193 }
18194
18195 local_free (induction_directory);
18196 }
18197 }
18198
18199 // outfile-check directory
18200
18201 if (outfile_check_dir == NULL)
18202 {
18203 if (rmdir (outfile_check_directory) == -1)
18204 {
18205 if (errno == ENOENT)
18206 {
18207 // good, we can ignore
18208 }
18209 else if (errno == ENOTEMPTY)
18210 {
18211 // good, we can ignore
18212 }
18213 else
18214 {
18215 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18216
18217 return (-1);
18218 }
18219 }
18220
18221 local_free (outfile_check_directory);
18222 }
18223
18224 time_t proc_stop;
18225
18226 time (&proc_stop);
18227
18228 logfile_top_uint (proc_start);
18229 logfile_top_uint (proc_stop);
18230
18231 logfile_top_msg ("STOP");
18232
18233 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18234 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18235
18236 if (data.ocl) ocl_close (data.ocl);
18237
18238 if (data.devices_status == STATUS_ABORTED) return 2;
18239 if (data.devices_status == STATUS_QUIT) return 2;
18240 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18241 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18242 if (data.devices_status == STATUS_CRACKED) return 0;
18243
18244 return -1;
18245 }
Hashcat additions to support pwdhash