projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Set maximum password length for SAP CODVN B (BCODE) hashes
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->device_vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->device_vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 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);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2613 {
2614 const u32 num16d = num / 16;
2615 const u32 num16m = num % 16;
2616
2617 if (num16d)
2618 {
2619 device_param->kernel_params_memset_buf32[1] = value;
2620 device_param->kernel_params_memset_buf32[2] = num16d;
2621
2622 uint kernel_threads = device_param->kernel_threads;
2623
2624 uint num_elements = num16d;
2625
2626 while (num_elements % kernel_threads) num_elements++;
2627
2628 cl_kernel kernel = device_param->kernel_memset;
2629
2630 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2631 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2632 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2633
2634 const size_t global_work_size[3] = { num_elements, 1, 1 };
2635 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2636
2637 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2638
2639 hc_clFlush (data.ocl, device_param->command_queue);
2640
2641 hc_clFinish (data.ocl, device_param->command_queue);
2642 }
2643
2644 if (num16m)
2645 {
2646 u32 tmp[4];
2647
2648 tmp[0] = value;
2649 tmp[1] = value;
2650 tmp[2] = value;
2651 tmp[3] = value;
2652
2653 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2654 }
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2658 {
2659 run_kernel_memset (device_param, buf, 0, size);
2660
2661 /*
2662 int rc = -1;
2663
2664 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2665 {
2666 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2667
2668 const cl_uchar zero = 0;
2669
2670 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2671 }
2672
2673 if (rc != 0)
2674 {
2675 // NOTE: clEnqueueFillBuffer () always fails with -59
2676 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2677 // How's that possible, OpenCL 1.2 support is advertised??
2678 // We need to workaround...
2679
2680 #define FILLSZ 0x100000
2681
2682 char *tmp = (char *) mymalloc (FILLSZ);
2683
2684 for (size_t i = 0; i < size; i += FILLSZ)
2685 {
2686 const size_t left = size - i;
2687
2688 const size_t fillsz = MIN (FILLSZ, left);
2689
2690 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2691 }
2692
2693 myfree (tmp);
2694 }
2695 */
2696 }
2697
2698 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)
2699 {
2700 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2701 {
2702 if (attack_mode == ATTACK_MODE_BF)
2703 {
2704 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2705 {
2706 const uint size_tm = 32 * sizeof (bs_word_t);
2707
2708 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2709
2710 run_kernel_tm (device_param);
2711
2712 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);
2713 }
2714 }
2715
2716 if (highest_pw_len < 16)
2717 {
2718 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2719 }
2720 else if (highest_pw_len < 32)
2721 {
2722 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2723 }
2724 else
2725 {
2726 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2727 }
2728 }
2729 else
2730 {
2731 run_kernel_amp (device_param, pws_cnt);
2732
2733 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2734
2735 if (opts_type & OPTS_TYPE_HOOK12)
2736 {
2737 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2738 }
2739
2740 uint iter = salt_buf->salt_iter;
2741
2742 uint loop_step = device_param->kernel_loops;
2743
2744 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2745 {
2746 uint loop_left = iter - loop_pos;
2747
2748 loop_left = MIN (loop_left, loop_step);
2749
2750 device_param->kernel_params_buf32[25] = loop_pos;
2751 device_param->kernel_params_buf32[26] = loop_left;
2752
2753 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2754
2755 if (data.devices_status == STATUS_CRACKED) break;
2756 if (data.devices_status == STATUS_ABORTED) break;
2757 if (data.devices_status == STATUS_QUIT) break;
2758
2759 /**
2760 * speed
2761 */
2762
2763 const float iter_part = (float) (loop_pos + loop_left) / iter;
2764
2765 const u64 perf_sum_all = pws_cnt * iter_part;
2766
2767 double speed_ms;
2768
2769 hc_timer_get (device_param->timer_speed, speed_ms);
2770
2771 const u32 speed_pos = device_param->speed_pos;
2772
2773 device_param->speed_cnt[speed_pos] = perf_sum_all;
2774
2775 device_param->speed_ms[speed_pos] = speed_ms;
2776
2777 if (data.benchmark == 1)
2778 {
2779 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2780 }
2781 }
2782
2783 if (opts_type & OPTS_TYPE_HOOK23)
2784 {
2785 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2786
2787 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);
2788
2789 // do something with data
2790
2791 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);
2792 }
2793
2794 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2795 }
2796 }
2797
2798 static int run_rule_engine (const int rule_len, const char *rule_buf)
2799 {
2800 if (rule_len == 0)
2801 {
2802 return 0;
2803 }
2804 else if (rule_len == 1)
2805 {
2806 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2807 }
2808
2809 return 1;
2810 }
2811
2812 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2813 {
2814 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2815 {
2816 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);
2817 }
2818 else if (data.attack_kern == ATTACK_KERN_COMBI)
2819 {
2820 if (data.attack_mode == ATTACK_MODE_COMBI)
2821 {
2822 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2823 {
2824 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2825 {
2826 for (u32 i = 0; i < pws_cnt; i++)
2827 {
2828 const u32 pw_len = device_param->pws_buf[i].pw_len;
2829
2830 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2831
2832 ptr[pw_len] = 0x01;
2833 }
2834 }
2835 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2836 {
2837 for (u32 i = 0; i < pws_cnt; i++)
2838 {
2839 const u32 pw_len = device_param->pws_buf[i].pw_len;
2840
2841 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2842
2843 ptr[pw_len] = 0x80;
2844 }
2845 }
2846 }
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2849 {
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 for (u32 i = 0; i < pws_cnt; i++)
2853 {
2854 const u32 pw_len = device_param->pws_buf[i].pw_len;
2855
2856 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2857
2858 ptr[pw_len] = 0x01;
2859 }
2860 }
2861 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2862 {
2863 for (u32 i = 0; i < pws_cnt; i++)
2864 {
2865 const u32 pw_len = device_param->pws_buf[i].pw_len;
2866
2867 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2868
2869 ptr[pw_len] = 0x80;
2870 }
2871 }
2872 }
2873
2874 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);
2875 }
2876 else if (data.attack_kern == ATTACK_KERN_BF)
2877 {
2878 const u64 off = device_param->words_off;
2879
2880 device_param->kernel_params_mp_l_buf64[3] = off;
2881
2882 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2883 }
2884 }
2885
2886 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2887 {
2888 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2889
2890 device_param->kernel_params_buf32[25] = 0;
2891 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2892 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2893
2894 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2895 {
2896 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2897 }
2898 else
2899 {
2900 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2901 }
2902
2903 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2904
2905 return exec_ms_prev;
2906 }
2907
2908 static void autotune (hc_device_param_t *device_param)
2909 {
2910 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2911
2912 const u32 kernel_accel_min = device_param->kernel_accel_min;
2913 const u32 kernel_accel_max = device_param->kernel_accel_max;
2914
2915 const u32 kernel_loops_min = device_param->kernel_loops_min;
2916 const u32 kernel_loops_max = device_param->kernel_loops_max;
2917
2918 u32 kernel_accel = kernel_accel_min;
2919 u32 kernel_loops = kernel_loops_min;
2920
2921 // in this case the user specified a fixed -u and -n on the commandline
2922 // no way to tune anything
2923 // but we need to run a few caching rounds
2924
2925 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2926 {
2927 try_run (device_param, kernel_accel, kernel_loops);
2928 try_run (device_param, kernel_accel, kernel_loops);
2929 try_run (device_param, kernel_accel, kernel_loops);
2930 try_run (device_param, kernel_accel, kernel_loops);
2931
2932 device_param->kernel_accel = kernel_accel;
2933 device_param->kernel_loops = kernel_loops;
2934
2935 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2936
2937 device_param->kernel_power = kernel_power;
2938
2939 return;
2940 }
2941
2942 // from here it's clear we are allowed to autotune
2943 // so let's init some fake words
2944
2945 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2946
2947 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2948
2949 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2950 {
2951 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2952 }
2953
2954 /*
2955 for (u32 i = 0; i < kernel_power_max; i++)
2956 {
2957 device_param->pws_buf[i].i[0] = i;
2958 device_param->pws_buf[i].i[1] = 0x01234567;
2959 device_param->pws_buf[i].pw_len = 7;
2960 }
2961
2962 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);
2963
2964 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2965 {
2966 run_kernel_amp (device_param, kernel_power_max);
2967 }
2968 */
2969
2970 #define VERIFIER_CNT 1
2971
2972 // first find out highest kernel-loops that stays below target_ms
2973
2974 if (kernel_loops_min < kernel_loops_max)
2975 {
2976 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2977 {
2978 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2979
2980 for (int i = 0; i < VERIFIER_CNT; i++)
2981 {
2982 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2983
2984 exec_ms = MIN (exec_ms, exec_ms_v);
2985 }
2986
2987 if (exec_ms < target_ms) break;
2988 }
2989 }
2990
2991 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2992
2993 #define STEPS_CNT 10
2994
2995 if (kernel_accel_min < kernel_accel_max)
2996 {
2997 for (int i = 0; i < STEPS_CNT; i++)
2998 {
2999 const u32 kernel_accel_try = 1 << i;
3000
3001 if (kernel_accel_try < kernel_accel_min) continue;
3002 if (kernel_accel_try > kernel_accel_max) break;
3003
3004 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3005
3006 for (int i = 0; i < VERIFIER_CNT; i++)
3007 {
3008 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3009
3010 exec_ms = MIN (exec_ms, exec_ms_v);
3011 }
3012
3013 if (exec_ms > target_ms) break;
3014
3015 kernel_accel = kernel_accel_try;
3016 }
3017 }
3018
3019 // at this point we want to know the actual runtime for the following reason:
3020 // we need a reference for the balancing loop following up, and this
3021 // the balancing loop can have an effect that the creates a new opportunity, for example:
3022 // if the target is 95 ms and the current runtime is 48ms the above loop
3023 // stopped the execution because the previous exec_ms was > 95ms
3024 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3025 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3026
3027 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3028
3029 for (int i = 0; i < VERIFIER_CNT; i++)
3030 {
3031 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3032
3033 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3034 }
3035
3036 u32 diff = kernel_loops - kernel_accel;
3037
3038 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3039 {
3040 u32 kernel_accel_orig = kernel_accel;
3041 u32 kernel_loops_orig = kernel_loops;
3042
3043 for (u32 f = 1; f < 1024; f++)
3044 {
3045 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3046 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3047
3048 if (kernel_accel_try > kernel_accel_max) break;
3049 if (kernel_loops_try < kernel_loops_min) break;
3050
3051 u32 diff_new = kernel_loops_try - kernel_accel_try;
3052
3053 if (diff_new > diff) break;
3054
3055 diff_new = diff;
3056
3057 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3058
3059 for (int i = 0; i < VERIFIER_CNT; i++)
3060 {
3061 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3062
3063 exec_ms = MIN (exec_ms, exec_ms_v);
3064 }
3065
3066 if (exec_ms < exec_ms_pre_final)
3067 {
3068 exec_ms_pre_final = exec_ms;
3069
3070 kernel_accel = kernel_accel_try;
3071 kernel_loops = kernel_loops_try;
3072 }
3073 }
3074 }
3075
3076 const double exec_left = target_ms / exec_ms_pre_final;
3077
3078 const double accel_left = kernel_accel_max / kernel_accel;
3079
3080 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3081
3082 if (exec_accel_min >= 1.0)
3083 {
3084 // this is safe to not overflow kernel_accel_max because of accel_left
3085
3086 kernel_accel = (double) kernel_accel * exec_accel_min;
3087 }
3088
3089 // reset them fake words
3090
3091 /*
3092 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3093
3094 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);
3095 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);
3096 */
3097
3098 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3099
3100 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3101 {
3102 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3103 }
3104
3105 // reset timer
3106
3107 device_param->exec_pos = 0;
3108
3109 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3110
3111 // store
3112
3113 device_param->kernel_accel = kernel_accel;
3114 device_param->kernel_loops = kernel_loops;
3115
3116 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3117
3118 device_param->kernel_power = kernel_power;
3119
3120 #ifdef DEBUG
3121
3122 if (data.quiet == 0)
3123 {
3124 clear_prompt ();
3125
3126 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3127 "Device #%u: autotuned kernel-loops to %u\n",
3128 device_param->device_id + 1, kernel_accel,
3129 device_param->device_id + 1, kernel_loops);
3130
3131 fprintf (stdout, "%s", PROMPT);
3132
3133 fflush (stdout);
3134 }
3135
3136 #endif
3137 }
3138
3139 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3140 {
3141 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3142
3143 // init speed timer
3144
3145 uint speed_pos = device_param->speed_pos;
3146
3147 #ifdef _POSIX
3148 if (device_param->timer_speed.tv_sec == 0)
3149 {
3150 hc_timer_set (&device_param->timer_speed);
3151 }
3152 #endif
3153
3154 #ifdef _WIN
3155 if (device_param->timer_speed.QuadPart == 0)
3156 {
3157 hc_timer_set (&device_param->timer_speed);
3158 }
3159 #endif
3160
3161 // find higest password length, this is for optimization stuff
3162
3163 uint highest_pw_len = 0;
3164
3165 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3166 {
3167 }
3168 else if (data.attack_kern == ATTACK_KERN_COMBI)
3169 {
3170 }
3171 else if (data.attack_kern == ATTACK_KERN_BF)
3172 {
3173 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3174 + device_param->kernel_params_mp_l_buf32[5];
3175 }
3176
3177 // iteration type
3178
3179 uint innerloop_step = 0;
3180 uint innerloop_cnt = 0;
3181
3182 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3183 else innerloop_step = 1;
3184
3185 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3186 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3187 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3188
3189 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3190
3191 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3192 {
3193 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3194
3195 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3196
3197 if (data.devices_status == STATUS_CRACKED) break;
3198 if (data.devices_status == STATUS_ABORTED) break;
3199 if (data.devices_status == STATUS_QUIT) break;
3200 if (data.devices_status == STATUS_BYPASS) break;
3201
3202 salt_t *salt_buf = &data.salts_buf[salt_pos];
3203
3204 device_param->kernel_params_buf32[24] = salt_pos;
3205 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3206 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3207
3208 FILE *combs_fp = device_param->combs_fp;
3209
3210 if (data.attack_mode == ATTACK_MODE_COMBI)
3211 {
3212 rewind (combs_fp);
3213 }
3214
3215 // innerloops
3216
3217 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3218 {
3219 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3220
3221 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3222
3223 if (data.devices_status == STATUS_CRACKED) break;
3224 if (data.devices_status == STATUS_ABORTED) break;
3225 if (data.devices_status == STATUS_QUIT) break;
3226 if (data.devices_status == STATUS_BYPASS) break;
3227
3228 uint innerloop_left = innerloop_cnt - innerloop_pos;
3229
3230 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3231
3232 device_param->innerloop_pos = innerloop_pos;
3233 device_param->innerloop_left = innerloop_left;
3234
3235 device_param->kernel_params_buf32[27] = innerloop_left;
3236
3237 // i think we can get rid of this
3238 if (innerloop_left == 0)
3239 {
3240 puts ("bug, how should this happen????\n");
3241
3242 continue;
3243 }
3244
3245 if (data.salts_shown[salt_pos] == 1)
3246 {
3247 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3248
3249 continue;
3250 }
3251
3252 // initialize amplifiers
3253
3254 if (data.attack_mode == ATTACK_MODE_COMBI)
3255 {
3256 uint i = 0;
3257
3258 while (i < innerloop_left)
3259 {
3260 if (feof (combs_fp)) break;
3261
3262 int line_len = fgetl (combs_fp, line_buf);
3263
3264 if (line_len >= PW_MAX1) continue;
3265
3266 line_len = convert_from_hex (line_buf, line_len);
3267
3268 char *line_buf_new = line_buf;
3269
3270 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3271 {
3272 char rule_buf_out[BLOCK_SIZE] = { 0 };
3273
3274 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3275
3276 if (rule_len_out < 0)
3277 {
3278 data.words_progress_rejected[salt_pos] += pws_cnt;
3279
3280 continue;
3281 }
3282
3283 line_len = rule_len_out;
3284
3285 line_buf_new = rule_buf_out;
3286 }
3287
3288 line_len = MIN (line_len, PW_DICTMAX);
3289
3290 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3291
3292 memcpy (ptr, line_buf_new, line_len);
3293
3294 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3295
3296 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3297 {
3298 uppercase (ptr, line_len);
3299 }
3300
3301 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3302 {
3303 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3304 {
3305 ptr[line_len] = 0x80;
3306 }
3307
3308 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3309 {
3310 ptr[line_len] = 0x01;
3311 }
3312 }
3313
3314 device_param->combs_buf[i].pw_len = line_len;
3315
3316 i++;
3317 }
3318
3319 for (uint j = i; j < innerloop_left; j++)
3320 {
3321 device_param->combs_buf[j].i[0] = 0;
3322 device_param->combs_buf[j].i[1] = 0;
3323 device_param->combs_buf[j].i[2] = 0;
3324 device_param->combs_buf[j].i[3] = 0;
3325 device_param->combs_buf[j].i[4] = 0;
3326 device_param->combs_buf[j].i[5] = 0;
3327 device_param->combs_buf[j].i[6] = 0;
3328 device_param->combs_buf[j].i[7] = 0;
3329
3330 device_param->combs_buf[j].pw_len = 0;
3331 }
3332
3333 innerloop_left = i;
3334 }
3335 else if (data.attack_mode == ATTACK_MODE_BF)
3336 {
3337 u64 off = innerloop_pos;
3338
3339 device_param->kernel_params_mp_r_buf64[3] = off;
3340
3341 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3342 }
3343 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3344 {
3345 u64 off = innerloop_pos;
3346
3347 device_param->kernel_params_mp_buf64[3] = off;
3348
3349 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3350 }
3351 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3352 {
3353 u64 off = innerloop_pos;
3354
3355 device_param->kernel_params_mp_buf64[3] = off;
3356
3357 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3358 }
3359
3360 // copy amplifiers
3361
3362 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3363 {
3364 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);
3365 }
3366 else if (data.attack_mode == ATTACK_MODE_COMBI)
3367 {
3368 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);
3369 }
3370 else if (data.attack_mode == ATTACK_MODE_BF)
3371 {
3372 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);
3373 }
3374 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3375 {
3376 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);
3377 }
3378 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3379 {
3380 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);
3381 }
3382
3383 if (data.benchmark == 1)
3384 {
3385 hc_timer_set (&device_param->timer_speed);
3386 }
3387
3388 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3389
3390 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3391
3392 if (data.devices_status == STATUS_CRACKED) break;
3393 if (data.devices_status == STATUS_ABORTED) break;
3394 if (data.devices_status == STATUS_QUIT) break;
3395
3396 /**
3397 * result
3398 */
3399
3400 check_cracked (device_param, salt_pos);
3401
3402 /**
3403 * progress
3404 */
3405
3406 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3407
3408 hc_thread_mutex_lock (mux_counter);
3409
3410 data.words_progress_done[salt_pos] += perf_sum_all;
3411
3412 hc_thread_mutex_unlock (mux_counter);
3413
3414 /**
3415 * speed
3416 */
3417
3418 double speed_ms;
3419
3420 hc_timer_get (device_param->timer_speed, speed_ms);
3421
3422 hc_timer_set (&device_param->timer_speed);
3423
3424 // current speed
3425
3426 //hc_thread_mutex_lock (mux_display);
3427
3428 device_param->speed_cnt[speed_pos] = perf_sum_all;
3429
3430 device_param->speed_ms[speed_pos] = speed_ms;
3431
3432 //hc_thread_mutex_unlock (mux_display);
3433
3434 speed_pos++;
3435
3436 if (speed_pos == SPEED_CACHE)
3437 {
3438 speed_pos = 0;
3439 }
3440
3441 /**
3442 * benchmark
3443 */
3444
3445 if (data.benchmark == 1) break;
3446 }
3447 }
3448
3449 device_param->speed_pos = speed_pos;
3450
3451 myfree (line_buf);
3452 }
3453
3454 static void load_segment (wl_data_t *wl_data, FILE *fd)
3455 {
3456 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3457
3458 wl_data->pos = 0;
3459
3460 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3461
3462 wl_data->buf[wl_data->cnt] = 0;
3463
3464 if (wl_data->cnt == 0) return;
3465
3466 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3467
3468 while (!feof (fd))
3469 {
3470 if (wl_data->cnt == wl_data->avail)
3471 {
3472 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3473
3474 wl_data->avail += wl_data->incr;
3475 }
3476
3477 const int c = fgetc (fd);
3478
3479 if (c == EOF) break;
3480
3481 wl_data->buf[wl_data->cnt] = (char) c;
3482
3483 wl_data->cnt++;
3484
3485 if (c == '\n') break;
3486 }
3487
3488 // ensure stream ends with a newline
3489
3490 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3491 {
3492 wl_data->cnt++;
3493
3494 wl_data->buf[wl_data->cnt - 1] = '\n';
3495 }
3496
3497 return;
3498 }
3499
3500 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3501 {
3502 char *ptr = buf;
3503
3504 for (u32 i = 0; i < sz; i++, ptr++)
3505 {
3506 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3507
3508 if (i == 7)
3509 {
3510 *off = i;
3511 *len = i;
3512
3513 return;
3514 }
3515
3516 if (*ptr != '\n') continue;
3517
3518 *off = i + 1;
3519
3520 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3521
3522 *len = i;
3523
3524 return;
3525 }
3526
3527 *off = sz;
3528 *len = sz;
3529 }
3530
3531 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3532 {
3533 char *ptr = buf;
3534
3535 for (u32 i = 0; i < sz; i++, ptr++)
3536 {
3537 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3538
3539 if (*ptr != '\n') continue;
3540
3541 *off = i + 1;
3542
3543 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3544
3545 *len = i;
3546
3547 return;
3548 }
3549
3550 *off = sz;
3551 *len = sz;
3552 }
3553
3554 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3555 {
3556 char *ptr = buf;
3557
3558 for (u32 i = 0; i < sz; i++, ptr++)
3559 {
3560 if (*ptr != '\n') continue;
3561
3562 *off = i + 1;
3563
3564 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3565
3566 *len = i;
3567
3568 return;
3569 }
3570
3571 *off = sz;
3572 *len = sz;
3573 }
3574
3575 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3576 {
3577 while (wl_data->pos < wl_data->cnt)
3578 {
3579 uint off;
3580 uint len;
3581
3582 char *ptr = wl_data->buf + wl_data->pos;
3583
3584 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3585
3586 wl_data->pos += off;
3587
3588 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3589 {
3590 char rule_buf_out[BLOCK_SIZE] = { 0 };
3591
3592 int rule_len_out = -1;
3593
3594 if (len < BLOCK_SIZE)
3595 {
3596 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3597 }
3598
3599 if (rule_len_out < 0)
3600 {
3601 continue;
3602 }
3603
3604 if (rule_len_out > PW_MAX)
3605 {
3606 continue;
3607 }
3608 }
3609 else
3610 {
3611 if (len > PW_MAX)
3612 {
3613 continue;
3614 }
3615 }
3616
3617 *out_buf = ptr;
3618 *out_len = len;
3619
3620 return;
3621 }
3622
3623 if (feof (fd))
3624 {
3625 fprintf (stderr, "BUG feof()!!\n");
3626
3627 return;
3628 }
3629
3630 load_segment (wl_data, fd);
3631
3632 get_next_word (wl_data, fd, out_buf, out_len);
3633 }
3634
3635 #ifdef _POSIX
3636 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3637 #endif
3638
3639 #ifdef _WIN
3640 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3641 #endif
3642 {
3643 hc_signal (NULL);
3644
3645 dictstat_t d;
3646
3647 d.cnt = 0;
3648
3649 #ifdef _POSIX
3650 fstat (fileno (fd), &d.stat);
3651 #endif
3652
3653 #ifdef _WIN
3654 _fstat64 (fileno (fd), &d.stat);
3655 #endif
3656
3657 d.stat.st_mode = 0;
3658 d.stat.st_nlink = 0;
3659 d.stat.st_uid = 0;
3660 d.stat.st_gid = 0;
3661 d.stat.st_rdev = 0;
3662 d.stat.st_atime = 0;
3663
3664 #ifdef _POSIX
3665 d.stat.st_blksize = 0;
3666 d.stat.st_blocks = 0;
3667 #endif
3668
3669 if (d.stat.st_size == 0) return 0;
3670
3671 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3672
3673 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3674 {
3675 if (d_cache)
3676 {
3677 u64 cnt = d_cache->cnt;
3678
3679 u64 keyspace = cnt;
3680
3681 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3682 {
3683 keyspace *= data.kernel_rules_cnt;
3684 }
3685 else if (data.attack_kern == ATTACK_KERN_COMBI)
3686 {
3687 keyspace *= data.combs_cnt;
3688 }
3689
3690 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);
3691 if (data.quiet == 0) log_info ("");
3692
3693 hc_signal (sigHandler_default);
3694
3695 return (keyspace);
3696 }
3697 }
3698
3699 time_t now = 0;
3700 time_t prev = 0;
3701
3702 u64 comp = 0;
3703 u64 cnt = 0;
3704 u64 cnt2 = 0;
3705
3706 while (!feof (fd))
3707 {
3708 load_segment (wl_data, fd);
3709
3710 comp += wl_data->cnt;
3711
3712 u32 i = 0;
3713
3714 while (i < wl_data->cnt)
3715 {
3716 u32 len;
3717 u32 off;
3718
3719 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3720
3721 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3722 {
3723 char rule_buf_out[BLOCK_SIZE] = { 0 };
3724
3725 int rule_len_out = -1;
3726
3727 if (len < BLOCK_SIZE)
3728 {
3729 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3730 }
3731
3732 if (rule_len_out < 0)
3733 {
3734 len = PW_MAX1;
3735 }
3736 else
3737 {
3738 len = rule_len_out;
3739 }
3740 }
3741
3742 if (len < PW_MAX1)
3743 {
3744 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3745 {
3746 cnt += data.kernel_rules_cnt;
3747 }
3748 else if (data.attack_kern == ATTACK_KERN_COMBI)
3749 {
3750 cnt += data.combs_cnt;
3751 }
3752
3753 d.cnt++;
3754 }
3755
3756 i += off;
3757
3758 cnt2++;
3759 }
3760
3761 time (&now);
3762
3763 if ((now - prev) == 0) continue;
3764
3765 float percent = (float) comp / (float) d.stat.st_size;
3766
3767 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);
3768
3769 time (&prev);
3770 }
3771
3772 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);
3773 if (data.quiet == 0) log_info ("");
3774
3775 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3776
3777 hc_signal (sigHandler_default);
3778
3779 return (cnt);
3780 }
3781
3782 static void *thread_monitor (void *p)
3783 {
3784 uint runtime_check = 0;
3785 uint remove_check = 0;
3786 uint status_check = 0;
3787 uint restore_check = 0;
3788
3789 uint restore_left = data.restore_timer;
3790 uint remove_left = data.remove_timer;
3791 uint status_left = data.status_timer;
3792
3793 #ifdef HAVE_HWMON
3794 uint hwmon_check = 0;
3795
3796 // these variables are mainly used for fan control (AMD only)
3797
3798 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3799
3800 // temperature controller "loopback" values
3801
3802 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3803 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3804
3805 #ifdef HAVE_ADL
3806 int temp_threshold = 1; // degrees celcius
3807
3808 int fan_speed_min = 15; // in percentage
3809 int fan_speed_max = 100;
3810 #endif // HAVE_ADL
3811
3812 time_t last_temp_check_time;
3813 #endif // HAVE_HWMON
3814
3815 uint sleep_time = 1;
3816
3817 if (data.runtime)
3818 {
3819 runtime_check = 1;
3820 }
3821
3822 if (data.restore_timer)
3823 {
3824 restore_check = 1;
3825 }
3826
3827 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3828 {
3829 remove_check = 1;
3830 }
3831
3832 if (data.status == 1)
3833 {
3834 status_check = 1;
3835 }
3836
3837 #ifdef HAVE_HWMON
3838 if (data.gpu_temp_disable == 0)
3839 {
3840 time (&last_temp_check_time);
3841
3842 hwmon_check = 1;
3843 }
3844 #endif
3845
3846 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3847 {
3848 #ifdef HAVE_HWMON
3849 if (hwmon_check == 0)
3850 #endif
3851 return (p);
3852 }
3853
3854 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3855 {
3856 hc_sleep (sleep_time);
3857
3858 if (data.devices_status != STATUS_RUNNING) continue;
3859
3860 #ifdef HAVE_HWMON
3861 if (hwmon_check == 1)
3862 {
3863 hc_thread_mutex_lock (mux_adl);
3864
3865 time_t temp_check_time;
3866
3867 time (&temp_check_time);
3868
3869 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3870
3871 if (Ta == 0) Ta = 1;
3872
3873 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3874 {
3875 hc_device_param_t *device_param = &data.devices_param[device_id];
3876
3877 if (device_param->skipped) continue;
3878
3879 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3880
3881 const int temperature = hm_get_temperature_with_device_id (device_id);
3882
3883 if (temperature > (int) data.gpu_temp_abort)
3884 {
3885 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3886
3887 if (data.devices_status != STATUS_QUIT) myabort ();
3888
3889 break;
3890 }
3891
3892 #ifdef HAVE_ADL
3893 const int gpu_temp_retain = data.gpu_temp_retain;
3894
3895 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3896 {
3897 if (data.hm_device[device_id].fan_supported == 1)
3898 {
3899 int temp_cur = temperature;
3900
3901 int temp_diff_new = gpu_temp_retain - temp_cur;
3902
3903 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3904
3905 // calculate Ta value (time difference in seconds between the last check and this check)
3906
3907 last_temp_check_time = temp_check_time;
3908
3909 float Kp = 1.8;
3910 float Ki = 0.005;
3911 float Kd = 6;
3912
3913 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3914
3915 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);
3916
3917 if (abs (fan_diff_required) >= temp_threshold)
3918 {
3919 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3920
3921 int fan_speed_level = fan_speed_cur;
3922
3923 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3924
3925 int fan_speed_new = fan_speed_level - fan_diff_required;
3926
3927 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3928 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3929
3930 if (fan_speed_new != fan_speed_cur)
3931 {
3932 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3933 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3934
3935 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3936 {
3937 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3938
3939 fan_speed_chgd[device_id] = 1;
3940 }
3941
3942 temp_diff_old[device_id] = temp_diff_new;
3943 }
3944 }
3945 }
3946 }
3947 #endif // HAVE_ADL
3948 }
3949
3950 hc_thread_mutex_unlock (mux_adl);
3951 }
3952 #endif // HAVE_HWMON
3953
3954 if (restore_check == 1)
3955 {
3956 restore_left--;
3957
3958 if (restore_left == 0)
3959 {
3960 if (data.restore_disable == 0) cycle_restore ();
3961
3962 restore_left = data.restore_timer;
3963 }
3964 }
3965
3966 if ((runtime_check == 1) && (data.runtime_start > 0))
3967 {
3968 time_t runtime_cur;
3969
3970 time (&runtime_cur);
3971
3972 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3973
3974 if (runtime_left <= 0)
3975 {
3976 if (data.benchmark == 0)
3977 {
3978 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3979 }
3980
3981 if (data.devices_status != STATUS_QUIT) myabort ();
3982 }
3983 }
3984
3985 if (remove_check == 1)
3986 {
3987 remove_left--;
3988
3989 if (remove_left == 0)
3990 {
3991 if (data.digests_saved != data.digests_done)
3992 {
3993 data.digests_saved = data.digests_done;
3994
3995 save_hash ();
3996 }
3997
3998 remove_left = data.remove_timer;
3999 }
4000 }
4001
4002 if (status_check == 1)
4003 {
4004 status_left--;
4005
4006 if (status_left == 0)
4007 {
4008 //hc_thread_mutex_lock (mux_display);
4009
4010 if (data.quiet == 0) clear_prompt ();
4011
4012 if (data.quiet == 0) log_info ("");
4013
4014 status_display ();
4015
4016 if (data.quiet == 0) log_info ("");
4017
4018 //hc_thread_mutex_unlock (mux_display);
4019
4020 status_left = data.status_timer;
4021 }
4022 }
4023 }
4024
4025 #ifdef HAVE_HWMON
4026 myfree (fan_speed_chgd);
4027
4028 myfree (temp_diff_old);
4029 myfree (temp_diff_sum);
4030 #endif
4031
4032 p = NULL;
4033
4034 return (p);
4035 }
4036
4037 static void *thread_outfile_remove (void *p)
4038 {
4039 // some hash-dependent constants
4040 char *outfile_dir = data.outfile_check_directory;
4041 uint dgst_size = data.dgst_size;
4042 uint isSalted = data.isSalted;
4043 uint esalt_size = data.esalt_size;
4044 uint hash_mode = data.hash_mode;
4045
4046 uint outfile_check_timer = data.outfile_check_timer;
4047
4048 char separator = data.separator;
4049
4050 // some hash-dependent functions
4051 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4052 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4053
4054 // buffers
4055 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4056
4057 hash_buf.digest = mymalloc (dgst_size);
4058
4059 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4060
4061 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4062
4063 uint digest_buf[64] = { 0 };
4064
4065 outfile_data_t *out_info = NULL;
4066
4067 char **out_files = NULL;
4068
4069 time_t folder_mtime = 0;
4070
4071 int out_cnt = 0;
4072
4073 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4074
4075 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4076 {
4077 hc_sleep (1);
4078
4079 if (data.devices_status != STATUS_RUNNING) continue;
4080
4081 check_left--;
4082
4083 if (check_left == 0)
4084 {
4085 struct stat outfile_check_stat;
4086
4087 if (stat (outfile_dir, &outfile_check_stat) == 0)
4088 {
4089 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4090
4091 if (is_dir == 1)
4092 {
4093 if (outfile_check_stat.st_mtime > folder_mtime)
4094 {
4095 char **out_files_new = scan_directory (outfile_dir);
4096
4097 int out_cnt_new = count_dictionaries (out_files_new);
4098
4099 outfile_data_t *out_info_new = NULL;
4100
4101 if (out_cnt_new > 0)
4102 {
4103 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4104
4105 for (int i = 0; i < out_cnt_new; i++)
4106 {
4107 out_info_new[i].file_name = out_files_new[i];
4108
4109 // check if there are files that we have seen/checked before (and not changed)
4110
4111 for (int j = 0; j < out_cnt; j++)
4112 {
4113 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4114 {
4115 struct stat outfile_stat;
4116
4117 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4118 {
4119 if (outfile_stat.st_ctime == out_info[j].ctime)
4120 {
4121 out_info_new[i].ctime = out_info[j].ctime;
4122 out_info_new[i].seek = out_info[j].seek;
4123 }
4124 }
4125 }
4126 }
4127 }
4128 }
4129
4130 local_free (out_info);
4131 local_free (out_files);
4132
4133 out_files = out_files_new;
4134 out_cnt = out_cnt_new;
4135 out_info = out_info_new;
4136
4137 folder_mtime = outfile_check_stat.st_mtime;
4138 }
4139
4140 for (int j = 0; j < out_cnt; j++)
4141 {
4142 FILE *fp = fopen (out_info[j].file_name, "rb");
4143
4144 if (fp != NULL)
4145 {
4146 //hc_thread_mutex_lock (mux_display);
4147
4148 #ifdef _POSIX
4149 struct stat outfile_stat;
4150
4151 fstat (fileno (fp), &outfile_stat);
4152 #endif
4153
4154 #ifdef _WIN
4155 struct stat64 outfile_stat;
4156
4157 _fstat64 (fileno (fp), &outfile_stat);
4158 #endif
4159
4160 if (outfile_stat.st_ctime > out_info[j].ctime)
4161 {
4162 out_info[j].ctime = outfile_stat.st_ctime;
4163 out_info[j].seek = 0;
4164 }
4165
4166 fseek (fp, out_info[j].seek, SEEK_SET);
4167
4168 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4169
4170 while (!feof (fp))
4171 {
4172 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4173
4174 if (ptr == NULL) break;
4175
4176 int line_len = strlen (line_buf);
4177
4178 if (line_len <= 0) continue;
4179
4180 int iter = MAX_CUT_TRIES;
4181
4182 for (uint i = line_len - 1; i && iter; i--, line_len--)
4183 {
4184 if (line_buf[i] != separator) continue;
4185
4186 int parser_status = PARSER_OK;
4187
4188 if ((hash_mode != 2500) && (hash_mode != 6800))
4189 {
4190 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4191 }
4192
4193 uint found = 0;
4194
4195 if (parser_status == PARSER_OK)
4196 {
4197 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4198 {
4199 if (data.salts_shown[salt_pos] == 1) continue;
4200
4201 salt_t *salt_buf = &data.salts_buf[salt_pos];
4202
4203 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4204 {
4205 uint idx = salt_buf->digests_offset + digest_pos;
4206
4207 if (data.digests_shown[idx] == 1) continue;
4208
4209 uint cracked = 0;
4210
4211 if (hash_mode == 6800)
4212 {
4213 if (i == salt_buf->salt_len)
4214 {
4215 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4216 }
4217 }
4218 else if (hash_mode == 2500)
4219 {
4220 // BSSID : MAC1 : MAC2 (:plain)
4221 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4222 {
4223 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4224
4225 if (!cracked) continue;
4226
4227 // now compare MAC1 and MAC2 too, since we have this additional info
4228 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4229 char *mac2_pos = mac1_pos + 12 + 1;
4230
4231 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4232 wpa_t *wpa = &wpas[salt_pos];
4233
4234 // compare hex string(s) vs binary MAC address(es)
4235
4236 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4237 {
4238 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4239 {
4240 cracked = 0;
4241
4242 break;
4243 }
4244 }
4245
4246 // early skip ;)
4247 if (!cracked) continue;
4248
4249 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4250 {
4251 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4252 {
4253 cracked = 0;
4254
4255 break;
4256 }
4257 }
4258 }
4259 }
4260 else
4261 {
4262 char *digests_buf_ptr = (char *) data.digests_buf;
4263
4264 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4265
4266 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4267 }
4268
4269 if (cracked == 1)
4270 {
4271 found = 1;
4272
4273 data.digests_shown[idx] = 1;
4274
4275 data.digests_done++;
4276
4277 salt_buf->digests_done++;
4278
4279 if (salt_buf->digests_done == salt_buf->digests_cnt)
4280 {
4281 data.salts_shown[salt_pos] = 1;
4282
4283 data.salts_done++;
4284
4285 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4286 }
4287 }
4288 }
4289
4290 if (data.devices_status == STATUS_CRACKED) break;
4291 }
4292 }
4293
4294 if (found) break;
4295
4296 if (data.devices_status == STATUS_CRACKED) break;
4297
4298 iter--;
4299 }
4300
4301 if (data.devices_status == STATUS_CRACKED) break;
4302 }
4303
4304 myfree (line_buf);
4305
4306 out_info[j].seek = ftell (fp);
4307
4308 //hc_thread_mutex_unlock (mux_display);
4309
4310 fclose (fp);
4311 }
4312 }
4313 }
4314 }
4315
4316 check_left = outfile_check_timer;
4317 }
4318 }
4319
4320 if (esalt_size) local_free (hash_buf.esalt);
4321
4322 if (isSalted) local_free (hash_buf.salt);
4323
4324 local_free (hash_buf.digest);
4325
4326 local_free (out_info);
4327
4328 local_free (out_files);
4329
4330 p = NULL;
4331
4332 return (p);
4333 }
4334
4335 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4336 {
4337 if (device_param->pws_cnt < device_param->kernel_power)
4338 {
4339 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4340
4341 u8 *ptr = (u8 *) pw->i;
4342
4343 memcpy (ptr, pw_buf, pw_len);
4344
4345 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4346
4347 pw->pw_len = pw_len;
4348
4349 device_param->pws_cnt++;
4350 }
4351 else
4352 {
4353 fprintf (stderr, "BUG pw_add()!!\n");
4354
4355 return;
4356 }
4357 }
4358
4359 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4360 {
4361 hc_thread_mutex_lock (mux_dispatcher);
4362
4363 const u64 words_cur = data.words_cur;
4364 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4365
4366 device_param->words_off = words_cur;
4367
4368 const u64 words_left = words_base - words_cur;
4369
4370 if (allow_div)
4371 {
4372 if (data.kernel_power_all > words_left)
4373 {
4374 if (data.kernel_power_div == 0)
4375 {
4376 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4377 }
4378 }
4379
4380 if (data.kernel_power_div)
4381 {
4382 if (device_param->kernel_power == device_param->kernel_power_user)
4383 {
4384 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4385
4386 if (kernel_power_new < device_param->kernel_power)
4387 {
4388 device_param->kernel_power = kernel_power_new;
4389 }
4390 }
4391 }
4392 }
4393
4394 const uint kernel_power = device_param->kernel_power;
4395
4396 uint work = MIN (words_left, kernel_power);
4397
4398 work = MIN (work, max);
4399
4400 data.words_cur += work;
4401
4402 hc_thread_mutex_unlock (mux_dispatcher);
4403
4404 return work;
4405 }
4406
4407 static void *thread_calc_stdin (void *p)
4408 {
4409 hc_device_param_t *device_param = (hc_device_param_t *) p;
4410
4411 if (device_param->skipped) return NULL;
4412
4413 autotune (device_param);
4414
4415 char *buf = (char *) mymalloc (HCBUFSIZ);
4416
4417 const uint attack_kern = data.attack_kern;
4418
4419 const uint kernel_power = device_param->kernel_power;
4420
4421 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4422 {
4423 hc_thread_mutex_lock (mux_dispatcher);
4424
4425 if (feof (stdin) != 0)
4426 {
4427 hc_thread_mutex_unlock (mux_dispatcher);
4428
4429 break;
4430 }
4431
4432 uint words_cur = 0;
4433
4434 while (words_cur < kernel_power)
4435 {
4436 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4437
4438 if (line_buf == NULL) break;
4439
4440 uint line_len = in_superchop (line_buf);
4441
4442 line_len = convert_from_hex (line_buf, line_len);
4443
4444 // post-process rule engine
4445
4446 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4447 {
4448 char rule_buf_out[BLOCK_SIZE] = { 0 };
4449
4450 int rule_len_out = -1;
4451
4452 if (line_len < BLOCK_SIZE)
4453 {
4454 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4455 }
4456
4457 if (rule_len_out < 0) continue;
4458
4459 line_buf = rule_buf_out;
4460 line_len = rule_len_out;
4461 }
4462
4463 if (line_len > PW_MAX)
4464 {
4465 continue;
4466 }
4467
4468 if (attack_kern == ATTACK_KERN_STRAIGHT)
4469 {
4470 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4471 {
4472 hc_thread_mutex_lock (mux_counter);
4473
4474 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4475 {
4476 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4477 }
4478
4479 hc_thread_mutex_unlock (mux_counter);
4480
4481 continue;
4482 }
4483 }
4484 else if (attack_kern == ATTACK_KERN_COMBI)
4485 {
4486 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4487 // since we still need to combine the plains
4488
4489 if (line_len > data.pw_max)
4490 {
4491 hc_thread_mutex_lock (mux_counter);
4492
4493 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4494 {
4495 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4496 }
4497
4498 hc_thread_mutex_unlock (mux_counter);
4499
4500 continue;
4501 }
4502 }
4503
4504 pw_add (device_param, (u8 *) line_buf, line_len);
4505
4506 words_cur++;
4507
4508 if (data.devices_status == STATUS_CRACKED) break;
4509 if (data.devices_status == STATUS_ABORTED) break;
4510 if (data.devices_status == STATUS_QUIT) break;
4511 if (data.devices_status == STATUS_BYPASS) break;
4512 }
4513
4514 hc_thread_mutex_unlock (mux_dispatcher);
4515
4516 if (data.devices_status == STATUS_CRACKED) break;
4517 if (data.devices_status == STATUS_ABORTED) break;
4518 if (data.devices_status == STATUS_QUIT) break;
4519 if (data.devices_status == STATUS_BYPASS) break;
4520
4521 // flush
4522
4523 const uint pws_cnt = device_param->pws_cnt;
4524
4525 if (pws_cnt)
4526 {
4527 run_copy (device_param, pws_cnt);
4528
4529 run_cracker (device_param, pws_cnt);
4530
4531 device_param->pws_cnt = 0;
4532
4533 /*
4534 still required?
4535 if (attack_kern == ATTACK_KERN_STRAIGHT)
4536 {
4537 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4538 }
4539 else if (attack_kern == ATTACK_KERN_COMBI)
4540 {
4541 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4542 }
4543 */
4544 }
4545 }
4546
4547 device_param->kernel_accel = 0;
4548 device_param->kernel_loops = 0;
4549
4550 myfree (buf);
4551
4552 return NULL;
4553 }
4554
4555 static void *thread_calc (void *p)
4556 {
4557 hc_device_param_t *device_param = (hc_device_param_t *) p;
4558
4559 if (device_param->skipped) return NULL;
4560
4561 autotune (device_param);
4562
4563 const uint attack_mode = data.attack_mode;
4564 const uint attack_kern = data.attack_kern;
4565
4566 if (attack_mode == ATTACK_MODE_BF)
4567 {
4568 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4569 {
4570 const uint work = get_work (device_param, -1, true);
4571
4572 if (work == 0) break;
4573
4574 const u64 words_off = device_param->words_off;
4575 const u64 words_fin = words_off + work;
4576
4577 const uint pws_cnt = work;
4578
4579 device_param->pws_cnt = pws_cnt;
4580
4581 if (pws_cnt)
4582 {
4583 run_copy (device_param, pws_cnt);
4584
4585 run_cracker (device_param, pws_cnt);
4586
4587 device_param->pws_cnt = 0;
4588
4589 /*
4590 still required?
4591 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4592 */
4593 }
4594
4595 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4596
4597 if (data.devices_status == STATUS_CRACKED) break;
4598 if (data.devices_status == STATUS_ABORTED) break;
4599 if (data.devices_status == STATUS_QUIT) break;
4600 if (data.devices_status == STATUS_BYPASS) break;
4601
4602 if (data.benchmark == 1) break;
4603
4604 device_param->words_done = words_fin;
4605 }
4606 }
4607 else
4608 {
4609 const uint segment_size = data.segment_size;
4610
4611 char *dictfile = data.dictfile;
4612
4613 if (attack_mode == ATTACK_MODE_COMBI)
4614 {
4615 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4616 {
4617 dictfile = data.dictfile2;
4618 }
4619 }
4620
4621 FILE *fd = fopen (dictfile, "rb");
4622
4623 if (fd == NULL)
4624 {
4625 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4626
4627 return NULL;
4628 }
4629
4630 if (attack_mode == ATTACK_MODE_COMBI)
4631 {
4632 const uint combs_mode = data.combs_mode;
4633
4634 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4635 {
4636 const char *dictfilec = data.dictfile2;
4637
4638 FILE *combs_fp = fopen (dictfilec, "rb");
4639
4640 if (combs_fp == NULL)
4641 {
4642 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4643
4644 fclose (fd);
4645
4646 return NULL;
4647 }
4648
4649 device_param->combs_fp = combs_fp;
4650 }
4651 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4652 {
4653 const char *dictfilec = data.dictfile;
4654
4655 FILE *combs_fp = fopen (dictfilec, "rb");
4656
4657 if (combs_fp == NULL)
4658 {
4659 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4660
4661 fclose (fd);
4662
4663 return NULL;
4664 }
4665
4666 device_param->combs_fp = combs_fp;
4667 }
4668 }
4669
4670 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4671
4672 wl_data->buf = (char *) mymalloc (segment_size);
4673 wl_data->avail = segment_size;
4674 wl_data->incr = segment_size;
4675 wl_data->cnt = 0;
4676 wl_data->pos = 0;
4677
4678 u64 words_cur = 0;
4679
4680 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4681 {
4682 u64 words_off = 0;
4683 u64 words_fin = 0;
4684
4685 bool allow_div = true;
4686
4687 u64 max = -1;
4688
4689 while (max)
4690 {
4691 const uint work = get_work (device_param, max, allow_div);
4692
4693 allow_div = false;
4694
4695 if (work == 0) break;
4696
4697 words_off = device_param->words_off;
4698 words_fin = words_off + work;
4699
4700 char *line_buf;
4701 uint line_len;
4702
4703 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4704
4705 max = 0;
4706
4707 for ( ; words_cur < words_fin; words_cur++)
4708 {
4709 get_next_word (wl_data, fd, &line_buf, &line_len);
4710
4711 line_len = convert_from_hex (line_buf, line_len);
4712
4713 // post-process rule engine
4714
4715 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4716 {
4717 char rule_buf_out[BLOCK_SIZE] = { 0 };
4718
4719 int rule_len_out = -1;
4720
4721 if (line_len < BLOCK_SIZE)
4722 {
4723 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4724 }
4725
4726 if (rule_len_out < 0) continue;
4727
4728 line_buf = rule_buf_out;
4729 line_len = rule_len_out;
4730 }
4731
4732 if (attack_kern == ATTACK_KERN_STRAIGHT)
4733 {
4734 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4735 {
4736 max++;
4737
4738 hc_thread_mutex_lock (mux_counter);
4739
4740 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4741 {
4742 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4743 }
4744
4745 hc_thread_mutex_unlock (mux_counter);
4746
4747 continue;
4748 }
4749 }
4750 else if (attack_kern == ATTACK_KERN_COMBI)
4751 {
4752 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4753 // since we still need to combine the plains
4754
4755 if (line_len > data.pw_max)
4756 {
4757 max++;
4758
4759 hc_thread_mutex_lock (mux_counter);
4760
4761 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4762 {
4763 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4764 }
4765
4766 hc_thread_mutex_unlock (mux_counter);
4767
4768 continue;
4769 }
4770 }
4771
4772 pw_add (device_param, (u8 *) line_buf, line_len);
4773
4774 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4775
4776 if (data.devices_status == STATUS_CRACKED) break;
4777 if (data.devices_status == STATUS_ABORTED) break;
4778 if (data.devices_status == STATUS_QUIT) break;
4779 if (data.devices_status == STATUS_BYPASS) break;
4780 }
4781
4782 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4783
4784 if (data.devices_status == STATUS_CRACKED) break;
4785 if (data.devices_status == STATUS_ABORTED) break;
4786 if (data.devices_status == STATUS_QUIT) break;
4787 if (data.devices_status == STATUS_BYPASS) break;
4788 }
4789
4790 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4791
4792 if (data.devices_status == STATUS_CRACKED) break;
4793 if (data.devices_status == STATUS_ABORTED) break;
4794 if (data.devices_status == STATUS_QUIT) break;
4795 if (data.devices_status == STATUS_BYPASS) break;
4796
4797 //
4798 // flush
4799 //
4800
4801 const uint pws_cnt = device_param->pws_cnt;
4802
4803 if (pws_cnt)
4804 {
4805 run_copy (device_param, pws_cnt);
4806
4807 run_cracker (device_param, pws_cnt);
4808
4809 device_param->pws_cnt = 0;
4810
4811 /*
4812 still required?
4813 if (attack_kern == ATTACK_KERN_STRAIGHT)
4814 {
4815 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4816 }
4817 else if (attack_kern == ATTACK_KERN_COMBI)
4818 {
4819 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4820 }
4821 */
4822 }
4823
4824 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4825
4826 if (data.devices_status == STATUS_CRACKED) break;
4827 if (data.devices_status == STATUS_ABORTED) break;
4828 if (data.devices_status == STATUS_QUIT) break;
4829 if (data.devices_status == STATUS_BYPASS) break;
4830
4831 if (words_fin == 0) break;
4832
4833 device_param->words_done = words_fin;
4834 }
4835
4836 if (attack_mode == ATTACK_MODE_COMBI)
4837 {
4838 fclose (device_param->combs_fp);
4839 }
4840
4841 free (wl_data->buf);
4842 free (wl_data);
4843
4844 fclose (fd);
4845 }
4846
4847 device_param->kernel_accel = 0;
4848 device_param->kernel_loops = 0;
4849
4850 return NULL;
4851 }
4852
4853 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4854 {
4855 if (!device_param)
4856 {
4857 log_error ("ERROR: %s : Invalid argument", __func__);
4858
4859 exit (-1);
4860 }
4861
4862 salt_t *salt_buf = &data.salts_buf[salt_pos];
4863
4864 device_param->kernel_params_buf32[24] = salt_pos;
4865 device_param->kernel_params_buf32[27] = 1;
4866 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4867 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4868 device_param->kernel_params_buf32[30] = 0;
4869 device_param->kernel_params_buf32[31] = 1;
4870
4871 char *dictfile_old = data.dictfile;
4872
4873 const char *weak_hash_check = "weak-hash-check";
4874
4875 data.dictfile = (char *) weak_hash_check;
4876
4877 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4878
4879 data.kernel_rules_buf[0].cmds[0] = 0;
4880
4881 /**
4882 * run the kernel
4883 */
4884
4885 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4886 {
4887 run_kernel (KERN_RUN_1, device_param, 1, false);
4888 }
4889 else
4890 {
4891 run_kernel (KERN_RUN_1, device_param, 1, false);
4892
4893 uint loop_step = 16;
4894
4895 const uint iter = salt_buf->salt_iter;
4896
4897 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4898 {
4899 uint loop_left = iter - loop_pos;
4900
4901 loop_left = MIN (loop_left, loop_step);
4902
4903 device_param->kernel_params_buf32[25] = loop_pos;
4904 device_param->kernel_params_buf32[26] = loop_left;
4905
4906 run_kernel (KERN_RUN_2, device_param, 1, false);
4907 }
4908
4909 run_kernel (KERN_RUN_3, device_param, 1, false);
4910 }
4911
4912 /**
4913 * result
4914 */
4915
4916 check_cracked (device_param, salt_pos);
4917
4918 /**
4919 * cleanup
4920 */
4921
4922 device_param->kernel_params_buf32[24] = 0;
4923 device_param->kernel_params_buf32[25] = 0;
4924 device_param->kernel_params_buf32[26] = 0;
4925 device_param->kernel_params_buf32[27] = 0;
4926 device_param->kernel_params_buf32[28] = 0;
4927 device_param->kernel_params_buf32[29] = 0;
4928 device_param->kernel_params_buf32[30] = 0;
4929 device_param->kernel_params_buf32[31] = 0;
4930
4931 data.dictfile = dictfile_old;
4932
4933 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4934 }
4935
4936 // hlfmt hashcat
4937
4938 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4939 {
4940 if (data.username == 0)
4941 {
4942 *hashbuf_pos = line_buf;
4943 *hashbuf_len = line_len;
4944 }
4945 else
4946 {
4947 char *pos = line_buf;
4948 int len = line_len;
4949
4950 for (int i = 0; i < line_len; i++, pos++, len--)
4951 {
4952 if (line_buf[i] == data.separator)
4953 {
4954 pos++;
4955
4956 len--;
4957
4958 break;
4959 }
4960 }
4961
4962 *hashbuf_pos = pos;
4963 *hashbuf_len = len;
4964 }
4965 }
4966
4967 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4968 {
4969 char *pos = NULL;
4970 int len = 0;
4971
4972 int sep_cnt = 0;
4973
4974 for (int i = 0; i < line_len; i++)
4975 {
4976 if (line_buf[i] == data.separator)
4977 {
4978 sep_cnt++;
4979
4980 continue;
4981 }
4982
4983 if (sep_cnt == 0)
4984 {
4985 if (pos == NULL) pos = line_buf + i;
4986
4987 len++;
4988 }
4989 }
4990
4991 *userbuf_pos = pos;
4992 *userbuf_len = len;
4993 }
4994
4995 // hlfmt pwdump
4996
4997 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4998 {
4999 int sep_cnt = 0;
5000
5001 int sep2_len = 0;
5002 int sep3_len = 0;
5003
5004 for (int i = 0; i < line_len; i++)
5005 {
5006 if (line_buf[i] == ':')
5007 {
5008 sep_cnt++;
5009
5010 continue;
5011 }
5012
5013 if (sep_cnt == 2) sep2_len++;
5014 if (sep_cnt == 3) sep3_len++;
5015 }
5016
5017 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5018
5019 return 0;
5020 }
5021
5022 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5023 {
5024 char *pos = NULL;
5025 int len = 0;
5026
5027 int sep_cnt = 0;
5028
5029 for (int i = 0; i < line_len; i++)
5030 {
5031 if (line_buf[i] == ':')
5032 {
5033 sep_cnt++;
5034
5035 continue;
5036 }
5037
5038 if (data.hash_mode == 1000)
5039 {
5040 if (sep_cnt == 3)
5041 {
5042 if (pos == NULL) pos = line_buf + i;
5043
5044 len++;
5045 }
5046 }
5047 else if (data.hash_mode == 3000)
5048 {
5049 if (sep_cnt == 2)
5050 {
5051 if (pos == NULL) pos = line_buf + i;
5052
5053 len++;
5054 }
5055 }
5056 }
5057
5058 *hashbuf_pos = pos;
5059 *hashbuf_len = len;
5060 }
5061
5062 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 char *pos = NULL;
5065 int len = 0;
5066
5067 int sep_cnt = 0;
5068
5069 for (int i = 0; i < line_len; i++)
5070 {
5071 if (line_buf[i] == ':')
5072 {
5073 sep_cnt++;
5074
5075 continue;
5076 }
5077
5078 if (sep_cnt == 0)
5079 {
5080 if (pos == NULL) pos = line_buf + i;
5081
5082 len++;
5083 }
5084 }
5085
5086 *userbuf_pos = pos;
5087 *userbuf_len = len;
5088 }
5089
5090 // hlfmt passwd
5091
5092 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5093 {
5094 int sep_cnt = 0;
5095
5096 char sep5_first = 0;
5097 char sep6_first = 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 (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5109 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5110 }
5111
5112 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5113
5114 return 0;
5115 }
5116
5117 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5118 {
5119 char *pos = NULL;
5120 int len = 0;
5121
5122 int sep_cnt = 0;
5123
5124 for (int i = 0; i < line_len; i++)
5125 {
5126 if (line_buf[i] == ':')
5127 {
5128 sep_cnt++;
5129
5130 continue;
5131 }
5132
5133 if (sep_cnt == 1)
5134 {
5135 if (pos == NULL) pos = line_buf + i;
5136
5137 len++;
5138 }
5139 }
5140
5141 *hashbuf_pos = pos;
5142 *hashbuf_len = len;
5143 }
5144
5145 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5146 {
5147 char *pos = NULL;
5148 int len = 0;
5149
5150 int sep_cnt = 0;
5151
5152 for (int i = 0; i < line_len; i++)
5153 {
5154 if (line_buf[i] == ':')
5155 {
5156 sep_cnt++;
5157
5158 continue;
5159 }
5160
5161 if (sep_cnt == 0)
5162 {
5163 if (pos == NULL) pos = line_buf + i;
5164
5165 len++;
5166 }
5167 }
5168
5169 *userbuf_pos = pos;
5170 *userbuf_len = len;
5171 }
5172
5173 // hlfmt shadow
5174
5175 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5176 {
5177 int sep_cnt = 0;
5178
5179 for (int i = 0; i < line_len; i++)
5180 {
5181 if (line_buf[i] == ':') sep_cnt++;
5182 }
5183
5184 if (sep_cnt == 8) return 1;
5185
5186 return 0;
5187 }
5188
5189 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5190 {
5191 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5192 }
5193
5194 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5195 {
5196 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5197 }
5198
5199 // hlfmt main
5200
5201 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5202 {
5203 switch (hashfile_format)
5204 {
5205 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5206 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5207 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5208 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5209 }
5210 }
5211
5212 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5213 {
5214 switch (hashfile_format)
5215 {
5216 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5217 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5218 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5219 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5220 }
5221 }
5222
5223 char *strhlfmt (const uint hashfile_format)
5224 {
5225 switch (hashfile_format)
5226 {
5227 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5228 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5229 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5230 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5231 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5232 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5233 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5234 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5235 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5236 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5237 }
5238
5239 return ((char *) "Unknown");
5240 }
5241
5242 static uint hlfmt_detect (FILE *fp, uint max_check)
5243 {
5244 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5245
5246 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5247 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5248
5249 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5250
5251 uint num_check = 0;
5252
5253 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5254
5255 while (!feof (fp))
5256 {
5257 int line_len = fgetl (fp, line_buf);
5258
5259 if (line_len == 0) continue;
5260
5261 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5262 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5263 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5264
5265 if (num_check == max_check) break;
5266
5267 num_check++;
5268 }
5269
5270 myfree (line_buf);
5271
5272 uint hashlist_format = HLFMT_HASHCAT;
5273
5274 for (int i = 1; i < HLFMTS_CNT; i++)
5275 {
5276 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5277
5278 hashlist_format = i;
5279 }
5280
5281 free (formats_cnt);
5282
5283 return hashlist_format;
5284 }
5285
5286 /**
5287 * some further helper function
5288 */
5289
5290 // wrapper around mymalloc for ADL
5291
5292 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5293 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5294 {
5295 return mymalloc (iSize);
5296 }
5297 #endif
5298
5299 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)
5300 {
5301 u64 collisions = 0;
5302
5303 const uint dgst_pos0 = data.dgst_pos0;
5304 const uint dgst_pos1 = data.dgst_pos1;
5305 const uint dgst_pos2 = data.dgst_pos2;
5306 const uint dgst_pos3 = data.dgst_pos3;
5307
5308 memset (bitmap_a, 0, bitmap_size);
5309 memset (bitmap_b, 0, bitmap_size);
5310 memset (bitmap_c, 0, bitmap_size);
5311 memset (bitmap_d, 0, bitmap_size);
5312
5313 for (uint i = 0; i < digests_cnt; i++)
5314 {
5315 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5316
5317 uint *digest_ptr = (uint *) digests_buf_ptr;
5318
5319 digests_buf_ptr += dgst_size;
5320
5321 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5322 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5323 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5324 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5325
5326 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5327 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5328 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5329 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5330
5331 if (bitmap_a[idx0] & val0) collisions++;
5332 if (bitmap_b[idx1] & val1) collisions++;
5333 if (bitmap_c[idx2] & val2) collisions++;
5334 if (bitmap_d[idx3] & val3) collisions++;
5335
5336 bitmap_a[idx0] |= val0;
5337 bitmap_b[idx1] |= val1;
5338 bitmap_c[idx2] |= val2;
5339 bitmap_d[idx3] |= val3;
5340
5341 if (collisions >= collisions_max) return 0x7fffffff;
5342 }
5343
5344 return collisions;
5345 }
5346
5347 /**
5348 * main
5349 */
5350
5351 int main (int argc, char **argv)
5352 {
5353 /**
5354 * To help users a bit
5355 */
5356
5357 char *compute = getenv ("COMPUTE");
5358
5359 if (compute)
5360 {
5361 static char display[100];
5362
5363 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5364
5365 putenv (display);
5366 }
5367 else
5368 {
5369 if (getenv ("DISPLAY") == NULL)
5370 putenv ((char *) "DISPLAY=:0");
5371 }
5372
5373 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5374 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5375
5376 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5377 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5378
5379 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5380 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5381
5382 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5383 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5384
5385 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5386 putenv ((char *) "POCL_KERNEL_CACHE=0");
5387
5388 umask (077);
5389
5390 /**
5391 * Real init
5392 */
5393
5394 memset (&data, 0, sizeof (hc_global_data_t));
5395
5396 time_t proc_start;
5397
5398 time (&proc_start);
5399
5400 data.proc_start = proc_start;
5401
5402 int myargc = argc;
5403 char **myargv = argv;
5404
5405 hc_thread_mutex_init (mux_dispatcher);
5406 hc_thread_mutex_init (mux_counter);
5407 hc_thread_mutex_init (mux_display);
5408 hc_thread_mutex_init (mux_adl);
5409
5410 /**
5411 * commandline parameters
5412 */
5413
5414 uint usage = USAGE;
5415 uint version = VERSION;
5416 uint quiet = QUIET;
5417 uint benchmark = BENCHMARK;
5418 uint show = SHOW;
5419 uint left = LEFT;
5420 uint username = USERNAME;
5421 uint remove = REMOVE;
5422 uint remove_timer = REMOVE_TIMER;
5423 u64 skip = SKIP;
5424 u64 limit = LIMIT;
5425 uint keyspace = KEYSPACE;
5426 uint potfile_disable = POTFILE_DISABLE;
5427 char *potfile_path = NULL;
5428 uint debug_mode = DEBUG_MODE;
5429 char *debug_file = NULL;
5430 char *induction_dir = NULL;
5431 char *outfile_check_dir = NULL;
5432 uint force = FORCE;
5433 uint runtime = RUNTIME;
5434 uint hash_mode = HASH_MODE;
5435 uint attack_mode = ATTACK_MODE;
5436 uint markov_disable = MARKOV_DISABLE;
5437 uint markov_classic = MARKOV_CLASSIC;
5438 uint markov_threshold = MARKOV_THRESHOLD;
5439 char *markov_hcstat = NULL;
5440 char *outfile = NULL;
5441 uint outfile_format = OUTFILE_FORMAT;
5442 uint outfile_autohex = OUTFILE_AUTOHEX;
5443 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5444 uint restore = RESTORE;
5445 uint restore_timer = RESTORE_TIMER;
5446 uint restore_disable = RESTORE_DISABLE;
5447 uint status = STATUS;
5448 uint status_timer = STATUS_TIMER;
5449 uint status_automat = STATUS_AUTOMAT;
5450 uint loopback = LOOPBACK;
5451 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5452 char *session = NULL;
5453 uint hex_charset = HEX_CHARSET;
5454 uint hex_salt = HEX_SALT;
5455 uint hex_wordlist = HEX_WORDLIST;
5456 uint rp_gen = RP_GEN;
5457 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5458 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5459 uint rp_gen_seed = RP_GEN_SEED;
5460 char *rule_buf_l = (char *) RULE_BUF_L;
5461 char *rule_buf_r = (char *) RULE_BUF_R;
5462 uint increment = INCREMENT;
5463 uint increment_min = INCREMENT_MIN;
5464 uint increment_max = INCREMENT_MAX;
5465 char *cpu_affinity = NULL;
5466 OCL_PTR *ocl = NULL;
5467 char *opencl_devices = NULL;
5468 char *opencl_platforms = NULL;
5469 char *opencl_device_types = NULL;
5470 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5471 char *truecrypt_keyfiles = NULL;
5472 char *veracrypt_keyfiles = NULL;
5473 uint veracrypt_pim = 0;
5474 uint workload_profile = WORKLOAD_PROFILE;
5475 uint kernel_accel = KERNEL_ACCEL;
5476 uint kernel_loops = KERNEL_LOOPS;
5477 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5478 #ifdef HAVE_HWMON
5479 uint gpu_temp_abort = GPU_TEMP_ABORT;
5480 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5481 #ifdef HAVE_ADL
5482 uint powertune_enable = POWERTUNE_ENABLE;
5483 #endif
5484 #endif
5485 uint logfile_disable = LOGFILE_DISABLE;
5486 uint segment_size = SEGMENT_SIZE;
5487 uint scrypt_tmto = SCRYPT_TMTO;
5488 char separator = SEPARATOR;
5489 uint bitmap_min = BITMAP_MIN;
5490 uint bitmap_max = BITMAP_MAX;
5491 char *custom_charset_1 = NULL;
5492 char *custom_charset_2 = NULL;
5493 char *custom_charset_3 = NULL;
5494 char *custom_charset_4 = NULL;
5495
5496 #define IDX_HELP 'h'
5497 #define IDX_VERSION 'V'
5498 #define IDX_VERSION_LOWER 'v'
5499 #define IDX_QUIET 0xff02
5500 #define IDX_SHOW 0xff03
5501 #define IDX_LEFT 0xff04
5502 #define IDX_REMOVE 0xff05
5503 #define IDX_REMOVE_TIMER 0xff37
5504 #define IDX_SKIP 's'
5505 #define IDX_LIMIT 'l'
5506 #define IDX_KEYSPACE 0xff35
5507 #define IDX_POTFILE_DISABLE 0xff06
5508 #define IDX_POTFILE_PATH 0xffe0
5509 #define IDX_DEBUG_MODE 0xff43
5510 #define IDX_DEBUG_FILE 0xff44
5511 #define IDX_INDUCTION_DIR 0xff46
5512 #define IDX_OUTFILE_CHECK_DIR 0xff47
5513 #define IDX_USERNAME 0xff07
5514 #define IDX_FORCE 0xff08
5515 #define IDX_RUNTIME 0xff09
5516 #define IDX_BENCHMARK 'b'
5517 #define IDX_HASH_MODE 'm'
5518 #define IDX_ATTACK_MODE 'a'
5519 #define IDX_RP_FILE 'r'
5520 #define IDX_RP_GEN 'g'
5521 #define IDX_RP_GEN_FUNC_MIN 0xff10
5522 #define IDX_RP_GEN_FUNC_MAX 0xff11
5523 #define IDX_RP_GEN_SEED 0xff34
5524 #define IDX_RULE_BUF_L 'j'
5525 #define IDX_RULE_BUF_R 'k'
5526 #define IDX_INCREMENT 'i'
5527 #define IDX_INCREMENT_MIN 0xff12
5528 #define IDX_INCREMENT_MAX 0xff13
5529 #define IDX_OUTFILE 'o'
5530 #define IDX_OUTFILE_FORMAT 0xff14
5531 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5532 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5533 #define IDX_RESTORE 0xff15
5534 #define IDX_RESTORE_DISABLE 0xff27
5535 #define IDX_STATUS 0xff17
5536 #define IDX_STATUS_TIMER 0xff18
5537 #define IDX_STATUS_AUTOMAT 0xff50
5538 #define IDX_LOOPBACK 0xff38
5539 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5540 #define IDX_SESSION 0xff19
5541 #define IDX_HEX_CHARSET 0xff20
5542 #define IDX_HEX_SALT 0xff21
5543 #define IDX_HEX_WORDLIST 0xff40
5544 #define IDX_MARKOV_DISABLE 0xff22
5545 #define IDX_MARKOV_CLASSIC 0xff23
5546 #define IDX_MARKOV_THRESHOLD 't'
5547 #define IDX_MARKOV_HCSTAT 0xff24
5548 #define IDX_CPU_AFFINITY 0xff25
5549 #define IDX_OPENCL_DEVICES 'd'
5550 #define IDX_OPENCL_PLATFORMS 0xff72
5551 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5552 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5553 #define IDX_WORKLOAD_PROFILE 'w'
5554 #define IDX_KERNEL_ACCEL 'n'
5555 #define IDX_KERNEL_LOOPS 'u'
5556 #define IDX_GPU_TEMP_DISABLE 0xff29
5557 #define IDX_GPU_TEMP_ABORT 0xff30
5558 #define IDX_GPU_TEMP_RETAIN 0xff31
5559 #define IDX_POWERTUNE_ENABLE 0xff41
5560 #define IDX_LOGFILE_DISABLE 0xff51
5561 #define IDX_TRUECRYPT_KEYFILES 0xff52
5562 #define IDX_VERACRYPT_KEYFILES 0xff53
5563 #define IDX_VERACRYPT_PIM 0xff54
5564 #define IDX_SCRYPT_TMTO 0xff61
5565 #define IDX_SEGMENT_SIZE 'c'
5566 #define IDX_SEPARATOR 'p'
5567 #define IDX_BITMAP_MIN 0xff70
5568 #define IDX_BITMAP_MAX 0xff71
5569 #define IDX_CUSTOM_CHARSET_1 '1'
5570 #define IDX_CUSTOM_CHARSET_2 '2'
5571 #define IDX_CUSTOM_CHARSET_3 '3'
5572 #define IDX_CUSTOM_CHARSET_4 '4'
5573
5574 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5575
5576 struct option long_options[] =
5577 {
5578 {"help", no_argument, 0, IDX_HELP},
5579 {"version", no_argument, 0, IDX_VERSION},
5580 {"quiet", no_argument, 0, IDX_QUIET},
5581 {"show", no_argument, 0, IDX_SHOW},
5582 {"left", no_argument, 0, IDX_LEFT},
5583 {"username", no_argument, 0, IDX_USERNAME},
5584 {"remove", no_argument, 0, IDX_REMOVE},
5585 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5586 {"skip", required_argument, 0, IDX_SKIP},
5587 {"limit", required_argument, 0, IDX_LIMIT},
5588 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5589 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5590 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5591 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5592 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5593 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5594 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5595 {"force", no_argument, 0, IDX_FORCE},
5596 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5597 {"restore", no_argument, 0, IDX_RESTORE},
5598 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5599 {"status", no_argument, 0, IDX_STATUS},
5600 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5601 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5602 {"loopback", no_argument, 0, IDX_LOOPBACK},
5603 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5604 {"session", required_argument, 0, IDX_SESSION},
5605 {"runtime", required_argument, 0, IDX_RUNTIME},
5606 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5607 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5608 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5609 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5610 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5611 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5612 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5613 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5614 {"rules-file", required_argument, 0, IDX_RP_FILE},
5615 {"outfile", required_argument, 0, IDX_OUTFILE},
5616 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5617 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5618 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5619 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5620 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5621 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5622 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5623 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5624 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5625 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5626 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5627 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5628 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5629 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5630 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5631 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5632 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5633 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5634 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5635 #ifdef HAVE_HWMON
5636 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5637 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5638 #ifdef HAVE_ADL
5639 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5640 #endif
5641 #endif // HAVE_HWMON
5642 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5643 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5644 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5645 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5646 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5647 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5648 {"seperator", required_argument, 0, IDX_SEPARATOR},
5649 {"separator", required_argument, 0, IDX_SEPARATOR},
5650 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5651 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5652 {"increment", no_argument, 0, IDX_INCREMENT},
5653 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5654 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5655 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5656 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5657 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5658 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5659 {0, 0, 0, 0}
5660 };
5661
5662 uint rp_files_cnt = 0;
5663
5664 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5665
5666 int option_index = 0;
5667 int c = -1;
5668
5669 optind = 1;
5670 optopt = 0;
5671
5672 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5673 {
5674 switch (c)
5675 {
5676 case IDX_HELP: usage = 1; break;
5677 case IDX_VERSION:
5678 case IDX_VERSION_LOWER: version = 1; break;
5679 case IDX_RESTORE: restore = 1; break;
5680 case IDX_SESSION: session = optarg; break;
5681 case IDX_SHOW: show = 1; break;
5682 case IDX_LEFT: left = 1; break;
5683 case '?': return (-1);
5684 }
5685 }
5686
5687 if (optopt != 0)
5688 {
5689 log_error ("ERROR: Invalid argument specified");
5690
5691 return (-1);
5692 }
5693
5694 /**
5695 * exit functions
5696 */
5697
5698 if (version)
5699 {
5700 log_info ("%s", VERSION_TAG);
5701
5702 return (0);
5703 }
5704
5705 if (usage)
5706 {
5707 usage_big_print (PROGNAME);
5708
5709 return (0);
5710 }
5711
5712 /**
5713 * session needs to be set, always!
5714 */
5715
5716 if (session == NULL) session = (char *) PROGNAME;
5717
5718 /**
5719 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5720 */
5721
5722 char *exec_path = get_exec_path ();
5723
5724 #ifdef LINUX
5725
5726 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5727 char *resolved_exec_path = realpath (exec_path, NULL);
5728
5729 char *install_dir = get_install_dir (resolved_exec_path);
5730 char *profile_dir = NULL;
5731 char *session_dir = NULL;
5732 char *shared_dir = NULL;
5733
5734 if (strcmp (install_dir, resolved_install_folder) == 0)
5735 {
5736 struct passwd *pw = getpwuid (getuid ());
5737
5738 const char *homedir = pw->pw_dir;
5739
5740 profile_dir = get_profile_dir (homedir);
5741 session_dir = get_session_dir (profile_dir);
5742 shared_dir = strdup (SHARED_FOLDER);
5743
5744 mkdir (profile_dir, 0700);
5745 mkdir (session_dir, 0700);
5746 }
5747 else
5748 {
5749 profile_dir = install_dir;
5750 session_dir = install_dir;
5751 shared_dir = install_dir;
5752 }
5753
5754 myfree (resolved_install_folder);
5755 myfree (resolved_exec_path);
5756
5757 #else
5758
5759 char *install_dir = get_install_dir (exec_path);
5760 char *profile_dir = install_dir;
5761 char *session_dir = install_dir;
5762 char *shared_dir = install_dir;
5763
5764 #endif
5765
5766 data.install_dir = install_dir;
5767 data.profile_dir = profile_dir;
5768 data.session_dir = session_dir;
5769 data.shared_dir = shared_dir;
5770
5771 myfree (exec_path);
5772
5773 /**
5774 * kernel cache, we need to make sure folder exist
5775 */
5776
5777 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5778
5779 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5780
5781 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5782
5783 mkdir (kernels_folder, 0700);
5784
5785 myfree (kernels_folder);
5786
5787 /**
5788 * session
5789 */
5790
5791 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5792
5793 data.session = session;
5794
5795 char *eff_restore_file = (char *) mymalloc (session_size);
5796 char *new_restore_file = (char *) mymalloc (session_size);
5797
5798 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5799 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5800
5801 data.eff_restore_file = eff_restore_file;
5802 data.new_restore_file = new_restore_file;
5803
5804 if (((show == 1) || (left == 1)) && (restore == 1))
5805 {
5806 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5807 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5808
5809 return (-1);
5810 }
5811
5812 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5813 if ((show == 1) || (left == 1))
5814 {
5815 restore_disable = 1;
5816
5817 restore = 0;
5818 }
5819
5820 data.restore_disable = restore_disable;
5821
5822 restore_data_t *rd = init_restore (argc, argv);
5823
5824 data.rd = rd;
5825
5826 /**
5827 * restore file
5828 */
5829
5830 if (restore == 1)
5831 {
5832 read_restore (eff_restore_file, rd);
5833
5834 if (rd->version_bin < RESTORE_MIN)
5835 {
5836 log_error ("ERROR: Incompatible restore-file version");
5837
5838 return (-1);
5839 }
5840
5841 myargc = rd->argc;
5842 myargv = rd->argv;
5843
5844 #ifdef _POSIX
5845 rd->pid = getpid ();
5846 #elif _WIN
5847 rd->pid = GetCurrentProcessId ();
5848 #endif
5849 }
5850
5851 uint hash_mode_chgd = 0;
5852 uint runtime_chgd = 0;
5853 uint kernel_loops_chgd = 0;
5854 uint kernel_accel_chgd = 0;
5855 uint attack_mode_chgd = 0;
5856 uint outfile_format_chgd = 0;
5857 uint rp_gen_seed_chgd = 0;
5858 uint remove_timer_chgd = 0;
5859 uint increment_min_chgd = 0;
5860 uint increment_max_chgd = 0;
5861 uint workload_profile_chgd = 0;
5862 uint opencl_vector_width_chgd = 0;
5863
5864 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5865 uint gpu_temp_retain_chgd = 0;
5866 uint gpu_temp_abort_chgd = 0;
5867 #endif
5868
5869 optind = 1;
5870 optopt = 0;
5871 option_index = 0;
5872
5873 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5874 {
5875 switch (c)
5876 {
5877 //case IDX_HELP: usage = 1; break;
5878 //case IDX_VERSION: version = 1; break;
5879 //case IDX_RESTORE: restore = 1; break;
5880 case IDX_QUIET: quiet = 1; break;
5881 //case IDX_SHOW: show = 1; break;
5882 case IDX_SHOW: break;
5883 //case IDX_LEFT: left = 1; break;
5884 case IDX_LEFT: break;
5885 case IDX_USERNAME: username = 1; break;
5886 case IDX_REMOVE: remove = 1; break;
5887 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5888 remove_timer_chgd = 1; break;
5889 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5890 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5891 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5892 case IDX_DEBUG_FILE: debug_file = optarg; break;
5893 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5894 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5895 case IDX_FORCE: force = 1; break;
5896 case IDX_SKIP: skip = atoll (optarg); break;
5897 case IDX_LIMIT: limit = atoll (optarg); break;
5898 case IDX_KEYSPACE: keyspace = 1; break;
5899 case IDX_BENCHMARK: benchmark = 1; break;
5900 case IDX_RESTORE: break;
5901 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5902 case IDX_STATUS: status = 1; break;
5903 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5904 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5905 case IDX_LOOPBACK: loopback = 1; break;
5906 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5907 //case IDX_SESSION: session = optarg; break;
5908 case IDX_SESSION: break;
5909 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5910 hash_mode_chgd = 1; break;
5911 case IDX_RUNTIME: runtime = atoi (optarg);
5912 runtime_chgd = 1; break;
5913 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5914 attack_mode_chgd = 1; break;
5915 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5916 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5917 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5918 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5919 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5920 rp_gen_seed_chgd = 1; break;
5921 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5922 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5923 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5924 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5925 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5926 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5927 case IDX_OUTFILE: outfile = optarg; break;
5928 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5929 outfile_format_chgd = 1; break;
5930 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5931 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5932 case IDX_HEX_CHARSET: hex_charset = 1; break;
5933 case IDX_HEX_SALT: hex_salt = 1; break;
5934 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5935 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5936 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5937 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5938 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5939 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5940 opencl_vector_width_chgd = 1; break;
5941 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5942 workload_profile_chgd = 1; break;
5943 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5944 kernel_accel_chgd = 1; break;
5945 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5946 kernel_loops_chgd = 1; break;
5947 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5948 #ifdef HAVE_HWMON
5949 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5950 #ifdef HAVE_ADL
5951 gpu_temp_abort_chgd = 1;
5952 #endif
5953 break;
5954 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5955 #ifdef HAVE_ADL
5956 gpu_temp_retain_chgd = 1;
5957 #endif
5958 break;
5959 #ifdef HAVE_ADL
5960 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5961 #endif
5962 #endif // HAVE_HWMON
5963 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5964 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5965 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5966 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5967 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5968 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5969 case IDX_SEPARATOR: separator = optarg[0]; break;
5970 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5971 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5972 case IDX_INCREMENT: increment = 1; break;
5973 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5974 increment_min_chgd = 1; break;
5975 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5976 increment_max_chgd = 1; break;
5977 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5978 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5979 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5980 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5981
5982 default:
5983 log_error ("ERROR: Invalid argument specified");
5984 return (-1);
5985 }
5986 }
5987
5988 if (optopt != 0)
5989 {
5990 log_error ("ERROR: Invalid argument specified");
5991
5992 return (-1);
5993 }
5994
5995 /**
5996 * Inform user things getting started,
5997 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5998 * - we do not need to check algorithm_pos
5999 */
6000
6001 if (quiet == 0)
6002 {
6003 if (benchmark == 1)
6004 {
6005 if (status_automat == 0)
6006 {
6007 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6008 log_info ("");
6009 }
6010 else
6011 {
6012 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6013 }
6014 }
6015 else if (restore == 1)
6016 {
6017 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6018 log_info ("");
6019 }
6020 else
6021 {
6022 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6023 log_info ("");
6024 }
6025 }
6026
6027 /**
6028 * sanity check
6029 */
6030
6031 if (attack_mode > 7)
6032 {
6033 log_error ("ERROR: Invalid attack-mode specified");
6034
6035 return (-1);
6036 }
6037
6038 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6039 {
6040 log_error ("ERROR: Invalid runtime specified");
6041
6042 return (-1);
6043 }
6044
6045 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6046 {
6047 log_error ("ERROR: Invalid hash-type specified");
6048
6049 return (-1);
6050 }
6051
6052 // renamed hash modes
6053
6054 if (hash_mode_chgd)
6055 {
6056 int n = -1;
6057
6058 switch (hash_mode)
6059 {
6060 case 123: n = 124;
6061 break;
6062 }
6063
6064 if (n >= 0)
6065 {
6066 log_error ("Old -m specified, use -m %d instead", n);
6067
6068 return (-1);
6069 }
6070 }
6071
6072 if (username == 1)
6073 {
6074 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6075 {
6076 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6077
6078 return (-1);
6079 }
6080 }
6081
6082 if (outfile_format > 16)
6083 {
6084 log_error ("ERROR: Invalid outfile-format specified");
6085
6086 return (-1);
6087 }
6088
6089 if (left == 1)
6090 {
6091 if (outfile_format_chgd == 1)
6092 {
6093 if (outfile_format > 1)
6094 {
6095 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6096
6097 return (-1);
6098 }
6099 }
6100 else
6101 {
6102 outfile_format = OUTFILE_FMT_HASH;
6103 }
6104 }
6105
6106 if (show == 1)
6107 {
6108 if (outfile_format_chgd == 1)
6109 {
6110 if ((outfile_format > 7) && (outfile_format < 16))
6111 {
6112 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6113
6114 return (-1);
6115 }
6116 }
6117 }
6118
6119 if (increment_min < INCREMENT_MIN)
6120 {
6121 log_error ("ERROR: Invalid increment-min specified");
6122
6123 return (-1);
6124 }
6125
6126 if (increment_max > INCREMENT_MAX)
6127 {
6128 log_error ("ERROR: Invalid increment-max specified");
6129
6130 return (-1);
6131 }
6132
6133 if (increment_min > increment_max)
6134 {
6135 log_error ("ERROR: Invalid increment-min specified");
6136
6137 return (-1);
6138 }
6139
6140 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6141 {
6142 log_error ("ERROR: increment is not allowed in attack-mode 0");
6143
6144 return (-1);
6145 }
6146
6147 if ((increment == 0) && (increment_min_chgd == 1))
6148 {
6149 log_error ("ERROR: increment-min is only supported together with increment switch");
6150
6151 return (-1);
6152 }
6153
6154 if ((increment == 0) && (increment_max_chgd == 1))
6155 {
6156 log_error ("ERROR: increment-max is only supported together with increment switch");
6157
6158 return (-1);
6159 }
6160
6161 if (rp_files_cnt && rp_gen)
6162 {
6163 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6164
6165 return (-1);
6166 }
6167
6168 if (rp_files_cnt || rp_gen)
6169 {
6170 if (attack_mode != ATTACK_MODE_STRAIGHT)
6171 {
6172 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (rp_gen_func_min > rp_gen_func_max)
6179 {
6180 log_error ("ERROR: Invalid rp-gen-func-min specified");
6181
6182 return (-1);
6183 }
6184
6185 if (kernel_accel_chgd == 1)
6186 {
6187 if (force == 0)
6188 {
6189 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6190 log_info ("Please consider using the option -w instead");
6191 log_info ("You can use --force to override this but do not post error reports if you do so");
6192 log_info ("");
6193
6194 return (-1);
6195 }
6196
6197 if (kernel_accel < 1)
6198 {
6199 log_error ("ERROR: Invalid kernel-accel specified");
6200
6201 return (-1);
6202 }
6203
6204 if (kernel_accel > 1024)
6205 {
6206 log_error ("ERROR: Invalid kernel-accel specified");
6207
6208 return (-1);
6209 }
6210 }
6211
6212 if (kernel_loops_chgd == 1)
6213 {
6214 if (force == 0)
6215 {
6216 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6217 log_info ("Please consider using the option -w instead");
6218 log_info ("You can use --force to override this but do not post error reports if you do so");
6219 log_info ("");
6220
6221 return (-1);
6222 }
6223
6224 if (kernel_loops < 1)
6225 {
6226 log_error ("ERROR: Invalid kernel-loops specified");
6227
6228 return (-1);
6229 }
6230
6231 if (kernel_loops > 1024)
6232 {
6233 log_error ("ERROR: Invalid kernel-loops specified");
6234
6235 return (-1);
6236 }
6237 }
6238
6239 if ((workload_profile < 1) || (workload_profile > 4))
6240 {
6241 log_error ("ERROR: workload-profile %i not available", workload_profile);
6242
6243 return (-1);
6244 }
6245
6246 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6247 {
6248 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6249
6250 return (-1);
6251 }
6252
6253 if (show == 1 || left == 1)
6254 {
6255 attack_mode = ATTACK_MODE_NONE;
6256
6257 if (remove == 1)
6258 {
6259 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6260
6261 return (-1);
6262 }
6263
6264 if (potfile_disable == 1)
6265 {
6266 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6267
6268 return (-1);
6269 }
6270 }
6271
6272 uint attack_kern = ATTACK_KERN_NONE;
6273
6274 switch (attack_mode)
6275 {
6276 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6277 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6278 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6279 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6280 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6281 }
6282
6283 if (benchmark == 0)
6284 {
6285 if (keyspace == 1)
6286 {
6287 int num_additional_params = 1;
6288
6289 if (attack_kern == ATTACK_KERN_COMBI)
6290 {
6291 num_additional_params = 2;
6292 }
6293
6294 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6295
6296 if (keyspace_wordlist_specified == 0) optind--;
6297 }
6298
6299 if (attack_kern == ATTACK_KERN_NONE)
6300 {
6301 if ((optind + 1) != myargc)
6302 {
6303 usage_mini_print (myargv[0]);
6304
6305 return (-1);
6306 }
6307 }
6308 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6309 {
6310 if ((optind + 1) > myargc)
6311 {
6312 usage_mini_print (myargv[0]);
6313
6314 return (-1);
6315 }
6316 }
6317 else if (attack_kern == ATTACK_KERN_COMBI)
6318 {
6319 if ((optind + 3) != myargc)
6320 {
6321 usage_mini_print (myargv[0]);
6322
6323 return (-1);
6324 }
6325 }
6326 else if (attack_kern == ATTACK_KERN_BF)
6327 {
6328 if ((optind + 1) > myargc)
6329 {
6330 usage_mini_print (myargv[0]);
6331
6332 return (-1);
6333 }
6334 }
6335 else
6336 {
6337 usage_mini_print (myargv[0]);
6338
6339 return (-1);
6340 }
6341 }
6342 else
6343 {
6344 if (myargv[optind] != 0)
6345 {
6346 log_error ("ERROR: Invalid argument for benchmark mode specified");
6347
6348 return (-1);
6349 }
6350
6351 if (attack_mode_chgd == 1)
6352 {
6353 if (attack_mode != ATTACK_MODE_BF)
6354 {
6355 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6356
6357 return (-1);
6358 }
6359 }
6360 }
6361
6362 if (skip != 0 && limit != 0)
6363 {
6364 limit += skip;
6365 }
6366
6367 if (keyspace == 1)
6368 {
6369 if (show == 1)
6370 {
6371 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6372
6373 return (-1);
6374 }
6375 else if (left == 1)
6376 {
6377 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6378
6379 return (-1);
6380 }
6381
6382 potfile_disable = 1;
6383
6384 restore_disable = 1;
6385
6386 restore = 0;
6387
6388 weak_hash_threshold = 0;
6389
6390 quiet = 1;
6391 }
6392
6393 if (remove_timer_chgd == 1)
6394 {
6395 if (remove == 0)
6396 {
6397 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6398
6399 return (-1);
6400 }
6401
6402 if (remove_timer < 1)
6403 {
6404 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6405
6406 return (-1);
6407 }
6408 }
6409
6410 if (loopback == 1)
6411 {
6412 if (attack_mode == ATTACK_MODE_STRAIGHT)
6413 {
6414 if ((rp_files_cnt == 0) && (rp_gen == 0))
6415 {
6416 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6417
6418 return (-1);
6419 }
6420 }
6421 else
6422 {
6423 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6424
6425 return (-1);
6426 }
6427 }
6428
6429 if (debug_mode > 0)
6430 {
6431 if (attack_mode != ATTACK_MODE_STRAIGHT)
6432 {
6433 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6434
6435 return (-1);
6436 }
6437
6438 if ((rp_files_cnt == 0) && (rp_gen == 0))
6439 {
6440 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6441
6442 return (-1);
6443 }
6444 }
6445
6446 if (debug_mode > 4)
6447 {
6448 log_error ("ERROR: Invalid debug-mode specified");
6449
6450 return (-1);
6451 }
6452
6453 if (debug_file != NULL)
6454 {
6455 if (debug_mode < 1)
6456 {
6457 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6458
6459 return (-1);
6460 }
6461 }
6462
6463 if (induction_dir != NULL)
6464 {
6465 if (attack_mode == ATTACK_MODE_BF)
6466 {
6467 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6468
6469 return (-1);
6470 }
6471 }
6472
6473 if (attack_mode != ATTACK_MODE_STRAIGHT)
6474 {
6475 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6476 {
6477 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6478
6479 return (-1);
6480 }
6481
6482 weak_hash_threshold = 0;
6483 }
6484
6485 /**
6486 * induction directory
6487 */
6488
6489 char *induction_directory = NULL;
6490
6491 if (attack_mode != ATTACK_MODE_BF)
6492 {
6493 if (induction_dir == NULL)
6494 {
6495 induction_directory = (char *) mymalloc (session_size);
6496
6497 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6498
6499 // create induction folder if it does not already exist
6500
6501 if (keyspace == 0)
6502 {
6503 if (rmdir (induction_directory) == -1)
6504 {
6505 if (errno == ENOENT)
6506 {
6507 // good, we can ignore
6508 }
6509 else if (errno == ENOTEMPTY)
6510 {
6511 char *induction_directory_mv = (char *) mymalloc (session_size);
6512
6513 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6514
6515 if (rename (induction_directory, induction_directory_mv) != 0)
6516 {
6517 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6518
6519 return (-1);
6520 }
6521 }
6522 else
6523 {
6524 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6525
6526 return (-1);
6527 }
6528 }
6529
6530 if (mkdir (induction_directory, 0700) == -1)
6531 {
6532 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6533
6534 return (-1);
6535 }
6536 }
6537 }
6538 else
6539 {
6540 induction_directory = induction_dir;
6541 }
6542 }
6543
6544 data.induction_directory = induction_directory;
6545
6546 /**
6547 * loopback
6548 */
6549
6550 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6551
6552 char *loopback_file = (char *) mymalloc (loopback_size);
6553
6554 /**
6555 * tuning db
6556 */
6557
6558 char tuning_db_file[256] = { 0 };
6559
6560 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6561
6562 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6563
6564 /**
6565 * outfile-check directory
6566 */
6567
6568 char *outfile_check_directory = NULL;
6569
6570 if (outfile_check_dir == NULL)
6571 {
6572 outfile_check_directory = (char *) mymalloc (session_size);
6573
6574 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6575 }
6576 else
6577 {
6578 outfile_check_directory = outfile_check_dir;
6579 }
6580
6581 data.outfile_check_directory = outfile_check_directory;
6582
6583 if (keyspace == 0)
6584 {
6585 struct stat outfile_check_stat;
6586
6587 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6588 {
6589 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6590
6591 if (is_dir == 0)
6592 {
6593 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6594
6595 return (-1);
6596 }
6597 }
6598 else if (outfile_check_dir == NULL)
6599 {
6600 if (mkdir (outfile_check_directory, 0700) == -1)
6601 {
6602 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6603
6604 return (-1);
6605 }
6606 }
6607 }
6608
6609 /**
6610 * special other stuff
6611 */
6612
6613 if (hash_mode == 9710)
6614 {
6615 outfile_format = 5;
6616 outfile_format_chgd = 1;
6617 }
6618
6619 if (hash_mode == 9810)
6620 {
6621 outfile_format = 5;
6622 outfile_format_chgd = 1;
6623 }
6624
6625 if (hash_mode == 10410)
6626 {
6627 outfile_format = 5;
6628 outfile_format_chgd = 1;
6629 }
6630
6631 /**
6632 * store stuff
6633 */
6634
6635 data.hash_mode = hash_mode;
6636 data.restore = restore;
6637 data.restore_timer = restore_timer;
6638 data.restore_disable = restore_disable;
6639 data.status = status;
6640 data.status_timer = status_timer;
6641 data.status_automat = status_automat;
6642 data.loopback = loopback;
6643 data.runtime = runtime;
6644 data.remove = remove;
6645 data.remove_timer = remove_timer;
6646 data.debug_mode = debug_mode;
6647 data.debug_file = debug_file;
6648 data.username = username;
6649 data.quiet = quiet;
6650 data.outfile = outfile;
6651 data.outfile_format = outfile_format;
6652 data.outfile_autohex = outfile_autohex;
6653 data.hex_charset = hex_charset;
6654 data.hex_salt = hex_salt;
6655 data.hex_wordlist = hex_wordlist;
6656 data.separator = separator;
6657 data.rp_files = rp_files;
6658 data.rp_files_cnt = rp_files_cnt;
6659 data.rp_gen = rp_gen;
6660 data.rp_gen_seed = rp_gen_seed;
6661 data.force = force;
6662 data.benchmark = benchmark;
6663 data.skip = skip;
6664 data.limit = limit;
6665 #ifdef HAVE_HWMON
6666 #ifdef HAVE_ADL
6667 data.powertune_enable = powertune_enable;
6668 #endif
6669 #endif
6670 data.logfile_disable = logfile_disable;
6671 data.truecrypt_keyfiles = truecrypt_keyfiles;
6672 data.veracrypt_keyfiles = veracrypt_keyfiles;
6673 data.veracrypt_pim = veracrypt_pim;
6674 data.scrypt_tmto = scrypt_tmto;
6675 data.workload_profile = workload_profile;
6676
6677 /**
6678 * cpu affinity
6679 */
6680
6681 if (cpu_affinity)
6682 {
6683 set_cpu_affinity (cpu_affinity);
6684 }
6685
6686 if (rp_gen_seed_chgd == 0)
6687 {
6688 srand (proc_start);
6689 }
6690 else
6691 {
6692 srand (rp_gen_seed);
6693 }
6694
6695 /**
6696 * logfile init
6697 */
6698
6699 if (logfile_disable == 0)
6700 {
6701 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6702
6703 char *logfile = (char *) mymalloc (logfile_size);
6704
6705 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6706
6707 data.logfile = logfile;
6708
6709 char *topid = logfile_generate_topid ();
6710
6711 data.topid = topid;
6712 }
6713
6714 // logfile_append() checks for logfile_disable internally to make it easier from here
6715
6716 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6717 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6718 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6719 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6720 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6721 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6722 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6723 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6724 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6725 #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));
6726
6727 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6728 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6729 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6730 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6731 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6732 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6733 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6734 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6735
6736 logfile_top_msg ("START");
6737
6738 logfile_top_uint (attack_mode);
6739 logfile_top_uint (attack_kern);
6740 logfile_top_uint (benchmark);
6741 logfile_top_uint (bitmap_min);
6742 logfile_top_uint (bitmap_max);
6743 logfile_top_uint (debug_mode);
6744 logfile_top_uint (force);
6745 logfile_top_uint (kernel_accel);
6746 logfile_top_uint (kernel_loops);
6747 logfile_top_uint (gpu_temp_disable);
6748 #ifdef HAVE_HWMON
6749 logfile_top_uint (gpu_temp_abort);
6750 logfile_top_uint (gpu_temp_retain);
6751 #endif
6752 logfile_top_uint (hash_mode);
6753 logfile_top_uint (hex_charset);
6754 logfile_top_uint (hex_salt);
6755 logfile_top_uint (hex_wordlist);
6756 logfile_top_uint (increment);
6757 logfile_top_uint (increment_max);
6758 logfile_top_uint (increment_min);
6759 logfile_top_uint (keyspace);
6760 logfile_top_uint (left);
6761 logfile_top_uint (logfile_disable);
6762 logfile_top_uint (loopback);
6763 logfile_top_uint (markov_classic);
6764 logfile_top_uint (markov_disable);
6765 logfile_top_uint (markov_threshold);
6766 logfile_top_uint (outfile_autohex);
6767 logfile_top_uint (outfile_check_timer);
6768 logfile_top_uint (outfile_format);
6769 logfile_top_uint (potfile_disable);
6770 logfile_top_string (potfile_path);
6771 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6772 logfile_top_uint (powertune_enable);
6773 #endif
6774 logfile_top_uint (scrypt_tmto);
6775 logfile_top_uint (quiet);
6776 logfile_top_uint (remove);
6777 logfile_top_uint (remove_timer);
6778 logfile_top_uint (restore);
6779 logfile_top_uint (restore_disable);
6780 logfile_top_uint (restore_timer);
6781 logfile_top_uint (rp_gen);
6782 logfile_top_uint (rp_gen_func_max);
6783 logfile_top_uint (rp_gen_func_min);
6784 logfile_top_uint (rp_gen_seed);
6785 logfile_top_uint (runtime);
6786 logfile_top_uint (segment_size);
6787 logfile_top_uint (show);
6788 logfile_top_uint (status);
6789 logfile_top_uint (status_automat);
6790 logfile_top_uint (status_timer);
6791 logfile_top_uint (usage);
6792 logfile_top_uint (username);
6793 logfile_top_uint (version);
6794 logfile_top_uint (weak_hash_threshold);
6795 logfile_top_uint (workload_profile);
6796 logfile_top_uint64 (limit);
6797 logfile_top_uint64 (skip);
6798 logfile_top_char (separator);
6799 logfile_top_string (cpu_affinity);
6800 logfile_top_string (custom_charset_1);
6801 logfile_top_string (custom_charset_2);
6802 logfile_top_string (custom_charset_3);
6803 logfile_top_string (custom_charset_4);
6804 logfile_top_string (debug_file);
6805 logfile_top_string (opencl_devices);
6806 logfile_top_string (opencl_platforms);
6807 logfile_top_string (opencl_device_types);
6808 logfile_top_uint (opencl_vector_width);
6809 logfile_top_string (induction_dir);
6810 logfile_top_string (markov_hcstat);
6811 logfile_top_string (outfile);
6812 logfile_top_string (outfile_check_dir);
6813 logfile_top_string (rule_buf_l);
6814 logfile_top_string (rule_buf_r);
6815 logfile_top_string (session);
6816 logfile_top_string (truecrypt_keyfiles);
6817 logfile_top_string (veracrypt_keyfiles);
6818 logfile_top_uint (veracrypt_pim);
6819
6820 /**
6821 * Init OpenCL library loader
6822 */
6823
6824 if (keyspace == 0)
6825 {
6826 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6827
6828 ocl_init (ocl);
6829
6830 data.ocl = ocl;
6831 }
6832
6833 /**
6834 * OpenCL platform selection
6835 */
6836
6837 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6838
6839 /**
6840 * OpenCL device selection
6841 */
6842
6843 u32 devices_filter = setup_devices_filter (opencl_devices);
6844
6845 /**
6846 * OpenCL device type selection
6847 */
6848
6849 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6850
6851 /**
6852 * benchmark
6853 */
6854
6855 if (benchmark == 1)
6856 {
6857 /**
6858 * disable useless stuff for benchmark
6859 */
6860
6861 status_timer = 0;
6862 restore_timer = 0;
6863 restore_disable = 1;
6864 potfile_disable = 1;
6865 weak_hash_threshold = 0;
6866 gpu_temp_disable = 1;
6867
6868 data.status_timer = status_timer;
6869 data.restore_timer = restore_timer;
6870 data.restore_disable = restore_disable;
6871
6872 /**
6873 * force attack mode to be bruteforce
6874 */
6875
6876 attack_mode = ATTACK_MODE_BF;
6877 attack_kern = ATTACK_KERN_BF;
6878
6879 if (workload_profile_chgd == 0)
6880 {
6881 workload_profile = 3;
6882
6883 data.workload_profile = workload_profile;
6884 }
6885 }
6886
6887 /**
6888 * config
6889 */
6890
6891 uint hash_type = 0;
6892 uint salt_type = 0;
6893 uint attack_exec = 0;
6894 uint opts_type = 0;
6895 uint kern_type = 0;
6896 uint dgst_size = 0;
6897 uint esalt_size = 0;
6898 uint opti_type = 0;
6899 uint dgst_pos0 = -1;
6900 uint dgst_pos1 = -1;
6901 uint dgst_pos2 = -1;
6902 uint dgst_pos3 = -1;
6903
6904 int (*parse_func) (char *, uint, hash_t *);
6905 int (*sort_by_digest) (const void *, const void *);
6906
6907 uint algorithm_pos = 0;
6908 uint algorithm_max = 1;
6909
6910 uint *algorithms = default_benchmark_algorithms;
6911
6912 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6913
6914 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6915 {
6916 /*
6917 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6918 * the following algos are skipped entirely
6919 */
6920
6921 if (algorithm_pos > 0)
6922 {
6923 local_free (rd);
6924
6925 rd = init_restore (argc, argv);
6926
6927 data.rd = rd;
6928 }
6929
6930 /**
6931 * update hash_mode in case of multihash benchmark
6932 */
6933
6934 if (benchmark == 1)
6935 {
6936 if (hash_mode_chgd == 0)
6937 {
6938 hash_mode = algorithms[algorithm_pos];
6939
6940 data.hash_mode = hash_mode;
6941 }
6942
6943 quiet = 1;
6944
6945 data.quiet = quiet;
6946 }
6947
6948 switch (hash_mode)
6949 {
6950 case 0: hash_type = HASH_TYPE_MD5;
6951 salt_type = SALT_TYPE_NONE;
6952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6953 opts_type = OPTS_TYPE_PT_GENERATE_LE
6954 | OPTS_TYPE_PT_ADD80
6955 | OPTS_TYPE_PT_ADDBITS14;
6956 kern_type = KERN_TYPE_MD5;
6957 dgst_size = DGST_SIZE_4_4;
6958 parse_func = md5_parse_hash;
6959 sort_by_digest = sort_by_digest_4_4;
6960 opti_type = OPTI_TYPE_ZERO_BYTE
6961 | OPTI_TYPE_PRECOMPUTE_INIT
6962 | OPTI_TYPE_PRECOMPUTE_MERKLE
6963 | OPTI_TYPE_MEET_IN_MIDDLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_NOT_SALTED
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 10: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_ST_ADD80
6979 | OPTS_TYPE_ST_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_PWSLT;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = md5s_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_MEET_IN_MIDDLE
6988 | OPTI_TYPE_EARLY_SKIP
6989 | OPTI_TYPE_NOT_ITERATED
6990 | OPTI_TYPE_APPENDED_SALT
6991 | OPTI_TYPE_RAW_HASH;
6992 dgst_pos0 = 0;
6993 dgst_pos1 = 3;
6994 dgst_pos2 = 2;
6995 dgst_pos3 = 1;
6996 break;
6997
6998 case 11: hash_type = HASH_TYPE_MD5;
6999 salt_type = SALT_TYPE_INTERN;
7000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7001 opts_type = OPTS_TYPE_PT_GENERATE_LE
7002 | OPTS_TYPE_ST_ADD80
7003 | OPTS_TYPE_ST_ADDBITS14;
7004 kern_type = KERN_TYPE_MD5_PWSLT;
7005 dgst_size = DGST_SIZE_4_4;
7006 parse_func = joomla_parse_hash;
7007 sort_by_digest = sort_by_digest_4_4;
7008 opti_type = OPTI_TYPE_ZERO_BYTE
7009 | OPTI_TYPE_PRECOMPUTE_INIT
7010 | OPTI_TYPE_PRECOMPUTE_MERKLE
7011 | OPTI_TYPE_MEET_IN_MIDDLE
7012 | OPTI_TYPE_EARLY_SKIP
7013 | OPTI_TYPE_NOT_ITERATED
7014 | OPTI_TYPE_APPENDED_SALT
7015 | OPTI_TYPE_RAW_HASH;
7016 dgst_pos0 = 0;
7017 dgst_pos1 = 3;
7018 dgst_pos2 = 2;
7019 dgst_pos3 = 1;
7020 break;
7021
7022 case 12: hash_type = HASH_TYPE_MD5;
7023 salt_type = SALT_TYPE_INTERN;
7024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7025 opts_type = OPTS_TYPE_PT_GENERATE_LE
7026 | OPTS_TYPE_ST_ADD80
7027 | OPTS_TYPE_ST_ADDBITS14;
7028 kern_type = KERN_TYPE_MD5_PWSLT;
7029 dgst_size = DGST_SIZE_4_4;
7030 parse_func = postgresql_parse_hash;
7031 sort_by_digest = sort_by_digest_4_4;
7032 opti_type = OPTI_TYPE_ZERO_BYTE
7033 | OPTI_TYPE_PRECOMPUTE_INIT
7034 | OPTI_TYPE_PRECOMPUTE_MERKLE
7035 | OPTI_TYPE_MEET_IN_MIDDLE
7036 | OPTI_TYPE_EARLY_SKIP
7037 | OPTI_TYPE_NOT_ITERATED
7038 | OPTI_TYPE_APPENDED_SALT
7039 | OPTI_TYPE_RAW_HASH;
7040 dgst_pos0 = 0;
7041 dgst_pos1 = 3;
7042 dgst_pos2 = 2;
7043 dgst_pos3 = 1;
7044 break;
7045
7046 case 20: hash_type = HASH_TYPE_MD5;
7047 salt_type = SALT_TYPE_INTERN;
7048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7049 opts_type = OPTS_TYPE_PT_GENERATE_LE
7050 | OPTS_TYPE_PT_ADD80
7051 | OPTS_TYPE_PT_ADDBITS14;
7052 kern_type = KERN_TYPE_MD5_SLTPW;
7053 dgst_size = DGST_SIZE_4_4;
7054 parse_func = md5s_parse_hash;
7055 sort_by_digest = sort_by_digest_4_4;
7056 opti_type = OPTI_TYPE_ZERO_BYTE
7057 | OPTI_TYPE_PRECOMPUTE_INIT
7058 | OPTI_TYPE_PRECOMPUTE_MERKLE
7059 | OPTI_TYPE_EARLY_SKIP
7060 | OPTI_TYPE_NOT_ITERATED
7061 | OPTI_TYPE_PREPENDED_SALT
7062 | OPTI_TYPE_RAW_HASH;
7063 dgst_pos0 = 0;
7064 dgst_pos1 = 3;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 21: hash_type = HASH_TYPE_MD5;
7070 salt_type = SALT_TYPE_INTERN;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_LE
7073 | OPTS_TYPE_PT_ADD80
7074 | OPTS_TYPE_PT_ADDBITS14;
7075 kern_type = KERN_TYPE_MD5_SLTPW;
7076 dgst_size = DGST_SIZE_4_4;
7077 parse_func = osc_parse_hash;
7078 sort_by_digest = sort_by_digest_4_4;
7079 opti_type = OPTI_TYPE_ZERO_BYTE
7080 | OPTI_TYPE_PRECOMPUTE_INIT
7081 | OPTI_TYPE_PRECOMPUTE_MERKLE
7082 | OPTI_TYPE_EARLY_SKIP
7083 | OPTI_TYPE_NOT_ITERATED
7084 | OPTI_TYPE_PREPENDED_SALT
7085 | OPTI_TYPE_RAW_HASH;
7086 dgst_pos0 = 0;
7087 dgst_pos1 = 3;
7088 dgst_pos2 = 2;
7089 dgst_pos3 = 1;
7090 break;
7091
7092 case 22: hash_type = HASH_TYPE_MD5;
7093 salt_type = SALT_TYPE_EMBEDDED;
7094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7095 opts_type = OPTS_TYPE_PT_GENERATE_LE
7096 | OPTS_TYPE_PT_ADD80
7097 | OPTS_TYPE_PT_ADDBITS14;
7098 kern_type = KERN_TYPE_MD5_SLTPW;
7099 dgst_size = DGST_SIZE_4_4;
7100 parse_func = netscreen_parse_hash;
7101 sort_by_digest = sort_by_digest_4_4;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_PRECOMPUTE_INIT
7104 | OPTI_TYPE_PRECOMPUTE_MERKLE
7105 | OPTI_TYPE_EARLY_SKIP
7106 | OPTI_TYPE_NOT_ITERATED
7107 | OPTI_TYPE_PREPENDED_SALT
7108 | OPTI_TYPE_RAW_HASH;
7109 dgst_pos0 = 0;
7110 dgst_pos1 = 3;
7111 dgst_pos2 = 2;
7112 dgst_pos3 = 1;
7113 break;
7114
7115 case 23: hash_type = HASH_TYPE_MD5;
7116 salt_type = SALT_TYPE_EMBEDDED;
7117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7118 opts_type = OPTS_TYPE_PT_GENERATE_LE
7119 | OPTS_TYPE_PT_ADD80
7120 | OPTS_TYPE_PT_ADDBITS14;
7121 kern_type = KERN_TYPE_MD5_SLTPW;
7122 dgst_size = DGST_SIZE_4_4;
7123 parse_func = skype_parse_hash;
7124 sort_by_digest = sort_by_digest_4_4;
7125 opti_type = OPTI_TYPE_ZERO_BYTE
7126 | OPTI_TYPE_PRECOMPUTE_INIT
7127 | OPTI_TYPE_PRECOMPUTE_MERKLE
7128 | OPTI_TYPE_EARLY_SKIP
7129 | OPTI_TYPE_NOT_ITERATED
7130 | OPTI_TYPE_PREPENDED_SALT
7131 | OPTI_TYPE_RAW_HASH;
7132 dgst_pos0 = 0;
7133 dgst_pos1 = 3;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 30: hash_type = HASH_TYPE_MD5;
7139 salt_type = SALT_TYPE_INTERN;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_LE
7142 | OPTS_TYPE_PT_UNICODE
7143 | OPTS_TYPE_ST_ADD80
7144 | OPTS_TYPE_ST_ADDBITS14;
7145 kern_type = KERN_TYPE_MD5_PWUSLT;
7146 dgst_size = DGST_SIZE_4_4;
7147 parse_func = md5s_parse_hash;
7148 sort_by_digest = sort_by_digest_4_4;
7149 opti_type = OPTI_TYPE_ZERO_BYTE
7150 | OPTI_TYPE_PRECOMPUTE_INIT
7151 | OPTI_TYPE_PRECOMPUTE_MERKLE
7152 | OPTI_TYPE_MEET_IN_MIDDLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED
7155 | OPTI_TYPE_APPENDED_SALT
7156 | OPTI_TYPE_RAW_HASH;
7157 dgst_pos0 = 0;
7158 dgst_pos1 = 3;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 40: hash_type = HASH_TYPE_MD5;
7164 salt_type = SALT_TYPE_INTERN;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_LE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS14
7169 | OPTS_TYPE_PT_UNICODE;
7170 kern_type = KERN_TYPE_MD5_SLTPWU;
7171 dgst_size = DGST_SIZE_4_4;
7172 parse_func = md5s_parse_hash;
7173 sort_by_digest = sort_by_digest_4_4;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_PREPENDED_SALT
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 0;
7182 dgst_pos1 = 3;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 50: hash_type = HASH_TYPE_MD5;
7188 salt_type = SALT_TYPE_INTERN;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_LE
7191 | OPTS_TYPE_ST_ADD80
7192 | OPTS_TYPE_ST_ADDBITS14;
7193 kern_type = KERN_TYPE_HMACMD5_PW;
7194 dgst_size = DGST_SIZE_4_4;
7195 parse_func = hmacmd5_parse_hash;
7196 sort_by_digest = sort_by_digest_4_4;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_NOT_ITERATED;
7199 dgst_pos0 = 0;
7200 dgst_pos1 = 3;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 60: hash_type = HASH_TYPE_MD5;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_LE
7209 | OPTS_TYPE_PT_ADD80
7210 | OPTS_TYPE_PT_ADDBITS14;
7211 kern_type = KERN_TYPE_HMACMD5_SLT;
7212 dgst_size = DGST_SIZE_4_4;
7213 parse_func = hmacmd5_parse_hash;
7214 sort_by_digest = sort_by_digest_4_4;
7215 opti_type = OPTI_TYPE_ZERO_BYTE
7216 | OPTI_TYPE_NOT_ITERATED;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 100: hash_type = HASH_TYPE_SHA1;
7224 salt_type = SALT_TYPE_NONE;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_BE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS15;
7229 kern_type = KERN_TYPE_SHA1;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = sha1_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_NOT_SALTED
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 3;
7241 dgst_pos1 = 4;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 101: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_NONE;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS15;
7252 kern_type = KERN_TYPE_SHA1;
7253 dgst_size = DGST_SIZE_4_5;
7254 parse_func = sha1b64_parse_hash;
7255 sort_by_digest = sort_by_digest_4_5;
7256 opti_type = OPTI_TYPE_ZERO_BYTE
7257 | OPTI_TYPE_PRECOMPUTE_INIT
7258 | OPTI_TYPE_PRECOMPUTE_MERKLE
7259 | OPTI_TYPE_EARLY_SKIP
7260 | OPTI_TYPE_NOT_ITERATED
7261 | OPTI_TYPE_NOT_SALTED
7262 | OPTI_TYPE_RAW_HASH;
7263 dgst_pos0 = 3;
7264 dgst_pos1 = 4;
7265 dgst_pos2 = 2;
7266 dgst_pos3 = 1;
7267 break;
7268
7269 case 110: hash_type = HASH_TYPE_SHA1;
7270 salt_type = SALT_TYPE_INTERN;
7271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7272 opts_type = OPTS_TYPE_PT_GENERATE_BE
7273 | OPTS_TYPE_ST_ADD80
7274 | OPTS_TYPE_ST_ADDBITS15;
7275 kern_type = KERN_TYPE_SHA1_PWSLT;
7276 dgst_size = DGST_SIZE_4_5;
7277 parse_func = sha1s_parse_hash;
7278 sort_by_digest = sort_by_digest_4_5;
7279 opti_type = OPTI_TYPE_ZERO_BYTE
7280 | OPTI_TYPE_PRECOMPUTE_INIT
7281 | OPTI_TYPE_PRECOMPUTE_MERKLE
7282 | OPTI_TYPE_EARLY_SKIP
7283 | OPTI_TYPE_NOT_ITERATED
7284 | OPTI_TYPE_APPENDED_SALT
7285 | OPTI_TYPE_RAW_HASH;
7286 dgst_pos0 = 3;
7287 dgst_pos1 = 4;
7288 dgst_pos2 = 2;
7289 dgst_pos3 = 1;
7290 break;
7291
7292 case 111: hash_type = HASH_TYPE_SHA1;
7293 salt_type = SALT_TYPE_EMBEDDED;
7294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7295 opts_type = OPTS_TYPE_PT_GENERATE_BE
7296 | OPTS_TYPE_ST_ADD80
7297 | OPTS_TYPE_ST_ADDBITS15;
7298 kern_type = KERN_TYPE_SHA1_PWSLT;
7299 dgst_size = DGST_SIZE_4_5;
7300 parse_func = sha1b64s_parse_hash;
7301 sort_by_digest = sort_by_digest_4_5;
7302 opti_type = OPTI_TYPE_ZERO_BYTE
7303 | OPTI_TYPE_PRECOMPUTE_INIT
7304 | OPTI_TYPE_PRECOMPUTE_MERKLE
7305 | OPTI_TYPE_EARLY_SKIP
7306 | OPTI_TYPE_NOT_ITERATED
7307 | OPTI_TYPE_APPENDED_SALT
7308 | OPTI_TYPE_RAW_HASH;
7309 dgst_pos0 = 3;
7310 dgst_pos1 = 4;
7311 dgst_pos2 = 2;
7312 dgst_pos3 = 1;
7313 break;
7314
7315 case 112: hash_type = HASH_TYPE_SHA1;
7316 salt_type = SALT_TYPE_INTERN;
7317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7318 opts_type = OPTS_TYPE_PT_GENERATE_BE
7319 | OPTS_TYPE_ST_ADD80
7320 | OPTS_TYPE_ST_ADDBITS15
7321 | OPTS_TYPE_ST_HEX;
7322 kern_type = KERN_TYPE_SHA1_PWSLT;
7323 dgst_size = DGST_SIZE_4_5;
7324 parse_func = oracles_parse_hash;
7325 sort_by_digest = sort_by_digest_4_5;
7326 opti_type = OPTI_TYPE_ZERO_BYTE
7327 | OPTI_TYPE_PRECOMPUTE_INIT
7328 | OPTI_TYPE_PRECOMPUTE_MERKLE
7329 | OPTI_TYPE_EARLY_SKIP
7330 | OPTI_TYPE_NOT_ITERATED
7331 | OPTI_TYPE_APPENDED_SALT
7332 | OPTI_TYPE_RAW_HASH;
7333 dgst_pos0 = 3;
7334 dgst_pos1 = 4;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 1;
7337 break;
7338
7339 case 120: hash_type = HASH_TYPE_SHA1;
7340 salt_type = SALT_TYPE_INTERN;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_BE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS15;
7345 kern_type = KERN_TYPE_SHA1_SLTPW;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = sha1s_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_PREPENDED_SALT
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 3;
7357 dgst_pos1 = 4;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 121: hash_type = HASH_TYPE_SHA1;
7363 salt_type = SALT_TYPE_INTERN;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_BE
7366 | OPTS_TYPE_PT_ADD80
7367 | OPTS_TYPE_PT_ADDBITS15
7368 | OPTS_TYPE_ST_LOWER;
7369 kern_type = KERN_TYPE_SHA1_SLTPW;
7370 dgst_size = DGST_SIZE_4_5;
7371 parse_func = smf_parse_hash;
7372 sort_by_digest = sort_by_digest_4_5;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_EARLY_SKIP
7377 | OPTI_TYPE_NOT_ITERATED
7378 | OPTI_TYPE_PREPENDED_SALT
7379 | OPTI_TYPE_RAW_HASH;
7380 dgst_pos0 = 3;
7381 dgst_pos1 = 4;
7382 dgst_pos2 = 2;
7383 dgst_pos3 = 1;
7384 break;
7385
7386 case 122: hash_type = HASH_TYPE_SHA1;
7387 salt_type = SALT_TYPE_EMBEDDED;
7388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7389 opts_type = OPTS_TYPE_PT_GENERATE_BE
7390 | OPTS_TYPE_PT_ADD80
7391 | OPTS_TYPE_PT_ADDBITS15
7392 | OPTS_TYPE_ST_HEX;
7393 kern_type = KERN_TYPE_SHA1_SLTPW;
7394 dgst_size = DGST_SIZE_4_5;
7395 parse_func = osx1_parse_hash;
7396 sort_by_digest = sort_by_digest_4_5;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_PRECOMPUTE_INIT
7399 | OPTI_TYPE_PRECOMPUTE_MERKLE
7400 | OPTI_TYPE_EARLY_SKIP
7401 | OPTI_TYPE_NOT_ITERATED
7402 | OPTI_TYPE_PREPENDED_SALT
7403 | OPTI_TYPE_RAW_HASH;
7404 dgst_pos0 = 3;
7405 dgst_pos1 = 4;
7406 dgst_pos2 = 2;
7407 dgst_pos3 = 1;
7408 break;
7409
7410 case 124: hash_type = HASH_TYPE_SHA1;
7411 salt_type = SALT_TYPE_EMBEDDED;
7412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7413 opts_type = OPTS_TYPE_PT_GENERATE_BE
7414 | OPTS_TYPE_PT_ADD80
7415 | OPTS_TYPE_PT_ADDBITS15;
7416 kern_type = KERN_TYPE_SHA1_SLTPW;
7417 dgst_size = DGST_SIZE_4_5;
7418 parse_func = djangosha1_parse_hash;
7419 sort_by_digest = sort_by_digest_4_5;
7420 opti_type = OPTI_TYPE_ZERO_BYTE
7421 | OPTI_TYPE_PRECOMPUTE_INIT
7422 | OPTI_TYPE_PRECOMPUTE_MERKLE
7423 | OPTI_TYPE_EARLY_SKIP
7424 | OPTI_TYPE_NOT_ITERATED
7425 | OPTI_TYPE_PREPENDED_SALT
7426 | OPTI_TYPE_RAW_HASH;
7427 dgst_pos0 = 3;
7428 dgst_pos1 = 4;
7429 dgst_pos2 = 2;
7430 dgst_pos3 = 1;
7431 break;
7432
7433 case 125: hash_type = HASH_TYPE_SHA1;
7434 salt_type = SALT_TYPE_EMBEDDED;
7435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7436 opts_type = OPTS_TYPE_PT_GENERATE_BE
7437 | OPTS_TYPE_PT_ADD80
7438 | OPTS_TYPE_PT_ADDBITS15
7439 | OPTS_TYPE_ST_HEX;
7440 kern_type = KERN_TYPE_SHA1_SLTPW;
7441 dgst_size = DGST_SIZE_4_5;
7442 parse_func = arubaos_parse_hash;
7443 sort_by_digest = sort_by_digest_4_5;
7444 opti_type = OPTI_TYPE_ZERO_BYTE
7445 | OPTI_TYPE_PRECOMPUTE_INIT
7446 | OPTI_TYPE_PRECOMPUTE_MERKLE
7447 | OPTI_TYPE_EARLY_SKIP
7448 | OPTI_TYPE_NOT_ITERATED
7449 | OPTI_TYPE_PREPENDED_SALT
7450 | OPTI_TYPE_RAW_HASH;
7451 dgst_pos0 = 3;
7452 dgst_pos1 = 4;
7453 dgst_pos2 = 2;
7454 dgst_pos3 = 1;
7455 break;
7456
7457 case 130: hash_type = HASH_TYPE_SHA1;
7458 salt_type = SALT_TYPE_INTERN;
7459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7460 opts_type = OPTS_TYPE_PT_GENERATE_BE
7461 | OPTS_TYPE_PT_UNICODE
7462 | OPTS_TYPE_ST_ADD80
7463 | OPTS_TYPE_ST_ADDBITS15;
7464 kern_type = KERN_TYPE_SHA1_PWUSLT;
7465 dgst_size = DGST_SIZE_4_5;
7466 parse_func = sha1s_parse_hash;
7467 sort_by_digest = sort_by_digest_4_5;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_EARLY_SKIP
7472 | OPTI_TYPE_NOT_ITERATED
7473 | OPTI_TYPE_APPENDED_SALT
7474 | OPTI_TYPE_RAW_HASH;
7475 dgst_pos0 = 3;
7476 dgst_pos1 = 4;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 1;
7479 break;
7480
7481 case 131: hash_type = HASH_TYPE_SHA1;
7482 salt_type = SALT_TYPE_EMBEDDED;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_UNICODE
7486 | OPTS_TYPE_PT_UPPER
7487 | OPTS_TYPE_ST_ADD80
7488 | OPTS_TYPE_ST_ADDBITS15
7489 | OPTS_TYPE_ST_HEX;
7490 kern_type = KERN_TYPE_SHA1_PWUSLT;
7491 dgst_size = DGST_SIZE_4_5;
7492 parse_func = mssql2000_parse_hash;
7493 sort_by_digest = sort_by_digest_4_5;
7494 opti_type = OPTI_TYPE_ZERO_BYTE
7495 | OPTI_TYPE_PRECOMPUTE_INIT
7496 | OPTI_TYPE_PRECOMPUTE_MERKLE
7497 | OPTI_TYPE_EARLY_SKIP
7498 | OPTI_TYPE_NOT_ITERATED
7499 | OPTI_TYPE_APPENDED_SALT
7500 | OPTI_TYPE_RAW_HASH;
7501 dgst_pos0 = 3;
7502 dgst_pos1 = 4;
7503 dgst_pos2 = 2;
7504 dgst_pos3 = 1;
7505 break;
7506
7507 case 132: hash_type = HASH_TYPE_SHA1;
7508 salt_type = SALT_TYPE_EMBEDDED;
7509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7510 opts_type = OPTS_TYPE_PT_GENERATE_BE
7511 | OPTS_TYPE_PT_UNICODE
7512 | OPTS_TYPE_ST_ADD80
7513 | OPTS_TYPE_ST_ADDBITS15
7514 | OPTS_TYPE_ST_HEX;
7515 kern_type = KERN_TYPE_SHA1_PWUSLT;
7516 dgst_size = DGST_SIZE_4_5;
7517 parse_func = mssql2005_parse_hash;
7518 sort_by_digest = sort_by_digest_4_5;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_EARLY_SKIP
7523 | OPTI_TYPE_NOT_ITERATED
7524 | OPTI_TYPE_APPENDED_SALT
7525 | OPTI_TYPE_RAW_HASH;
7526 dgst_pos0 = 3;
7527 dgst_pos1 = 4;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 1;
7530 break;
7531
7532 case 133: hash_type = HASH_TYPE_SHA1;
7533 salt_type = SALT_TYPE_EMBEDDED;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_BE
7536 | OPTS_TYPE_PT_UNICODE
7537 | OPTS_TYPE_ST_ADD80
7538 | OPTS_TYPE_ST_ADDBITS15;
7539 kern_type = KERN_TYPE_SHA1_PWUSLT;
7540 dgst_size = DGST_SIZE_4_5;
7541 parse_func = peoplesoft_parse_hash;
7542 sort_by_digest = sort_by_digest_4_5;
7543 opti_type = OPTI_TYPE_ZERO_BYTE
7544 | OPTI_TYPE_PRECOMPUTE_INIT
7545 | OPTI_TYPE_PRECOMPUTE_MERKLE
7546 | OPTI_TYPE_EARLY_SKIP
7547 | OPTI_TYPE_NOT_ITERATED
7548 | OPTI_TYPE_APPENDED_SALT
7549 | OPTI_TYPE_RAW_HASH;
7550 dgst_pos0 = 3;
7551 dgst_pos1 = 4;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 140: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_INTERN;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15
7562 | OPTS_TYPE_PT_UNICODE;
7563 kern_type = KERN_TYPE_SHA1_SLTPWU;
7564 dgst_size = DGST_SIZE_4_5;
7565 parse_func = sha1s_parse_hash;
7566 sort_by_digest = sort_by_digest_4_5;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_EARLY_SKIP
7571 | OPTI_TYPE_NOT_ITERATED
7572 | OPTI_TYPE_PREPENDED_SALT
7573 | OPTI_TYPE_RAW_HASH;
7574 dgst_pos0 = 3;
7575 dgst_pos1 = 4;
7576 dgst_pos2 = 2;
7577 dgst_pos3 = 1;
7578 break;
7579
7580 case 141: hash_type = HASH_TYPE_SHA1;
7581 salt_type = SALT_TYPE_EMBEDDED;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = OPTS_TYPE_PT_GENERATE_BE
7584 | OPTS_TYPE_PT_ADD80
7585 | OPTS_TYPE_PT_ADDBITS15
7586 | OPTS_TYPE_PT_UNICODE
7587 | OPTS_TYPE_ST_BASE64;
7588 kern_type = KERN_TYPE_SHA1_SLTPWU;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = episerver_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_PREPENDED_SALT
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 3;
7600 dgst_pos1 = 4;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 150: hash_type = HASH_TYPE_SHA1;
7606 salt_type = SALT_TYPE_INTERN;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_BE
7609 | OPTS_TYPE_ST_ADD80
7610 | OPTS_TYPE_ST_ADDBITS15;
7611 kern_type = KERN_TYPE_HMACSHA1_PW;
7612 dgst_size = DGST_SIZE_4_5;
7613 parse_func = hmacsha1_parse_hash;
7614 sort_by_digest = sort_by_digest_4_5;
7615 opti_type = OPTI_TYPE_ZERO_BYTE
7616 | OPTI_TYPE_NOT_ITERATED;
7617 dgst_pos0 = 3;
7618 dgst_pos1 = 4;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 1;
7621 break;
7622
7623 case 160: hash_type = HASH_TYPE_SHA1;
7624 salt_type = SALT_TYPE_INTERN;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_PT_ADD80
7628 | OPTS_TYPE_PT_ADDBITS15;
7629 kern_type = KERN_TYPE_HMACSHA1_SLT;
7630 dgst_size = DGST_SIZE_4_5;
7631 parse_func = hmacsha1_parse_hash;
7632 sort_by_digest = sort_by_digest_4_5;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_NOT_ITERATED;
7635 dgst_pos0 = 3;
7636 dgst_pos1 = 4;
7637 dgst_pos2 = 2;
7638 dgst_pos3 = 1;
7639 break;
7640
7641 case 190: hash_type = HASH_TYPE_SHA1;
7642 salt_type = SALT_TYPE_NONE;
7643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7644 opts_type = OPTS_TYPE_PT_GENERATE_BE
7645 | OPTS_TYPE_PT_ADD80
7646 | OPTS_TYPE_PT_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7648 dgst_size = DGST_SIZE_4_5;
7649 parse_func = sha1linkedin_parse_hash;
7650 sort_by_digest = sort_by_digest_4_5;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_EARLY_SKIP
7654 | OPTI_TYPE_NOT_ITERATED
7655 | OPTI_TYPE_NOT_SALTED;
7656 dgst_pos0 = 0;
7657 dgst_pos1 = 4;
7658 dgst_pos2 = 3;
7659 dgst_pos3 = 2;
7660 break;
7661
7662 case 200: hash_type = HASH_TYPE_MYSQL;
7663 salt_type = SALT_TYPE_NONE;
7664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7665 opts_type = 0;
7666 kern_type = KERN_TYPE_MYSQL;
7667 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7668 parse_func = mysql323_parse_hash;
7669 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7670 opti_type = OPTI_TYPE_ZERO_BYTE;
7671 dgst_pos0 = 0;
7672 dgst_pos1 = 1;
7673 dgst_pos2 = 2;
7674 dgst_pos3 = 3;
7675 break;
7676
7677 case 300: hash_type = HASH_TYPE_SHA1;
7678 salt_type = SALT_TYPE_NONE;
7679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680 opts_type = OPTS_TYPE_PT_GENERATE_BE
7681 | OPTS_TYPE_PT_ADD80
7682 | OPTS_TYPE_PT_ADDBITS15;
7683 kern_type = KERN_TYPE_MYSQL41;
7684 dgst_size = DGST_SIZE_4_5;
7685 parse_func = sha1_parse_hash;
7686 sort_by_digest = sort_by_digest_4_5;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_PRECOMPUTE_MERKLE
7690 | OPTI_TYPE_EARLY_SKIP
7691 | OPTI_TYPE_NOT_ITERATED
7692 | OPTI_TYPE_NOT_SALTED;
7693 dgst_pos0 = 3;
7694 dgst_pos1 = 4;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 1;
7697 break;
7698
7699 case 400: hash_type = HASH_TYPE_MD5;
7700 salt_type = SALT_TYPE_EMBEDDED;
7701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7703 kern_type = KERN_TYPE_PHPASS;
7704 dgst_size = DGST_SIZE_4_4;
7705 parse_func = phpass_parse_hash;
7706 sort_by_digest = sort_by_digest_4_4;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_SLOW_HASH_SIMD;
7709 dgst_pos0 = 0;
7710 dgst_pos1 = 1;
7711 dgst_pos2 = 2;
7712 dgst_pos3 = 3;
7713 break;
7714
7715 case 500: hash_type = HASH_TYPE_MD5;
7716 salt_type = SALT_TYPE_EMBEDDED;
7717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7718 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7719 kern_type = KERN_TYPE_MD5CRYPT;
7720 dgst_size = DGST_SIZE_4_4;
7721 parse_func = md5crypt_parse_hash;
7722 sort_by_digest = sort_by_digest_4_4;
7723 opti_type = OPTI_TYPE_ZERO_BYTE;
7724 dgst_pos0 = 0;
7725 dgst_pos1 = 1;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 3;
7728 break;
7729
7730 case 501: hash_type = HASH_TYPE_MD5;
7731 salt_type = SALT_TYPE_EMBEDDED;
7732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_LE
7734 | OPTS_TYPE_HASH_COPY;
7735 kern_type = KERN_TYPE_MD5CRYPT;
7736 dgst_size = DGST_SIZE_4_4;
7737 parse_func = juniper_parse_hash;
7738 sort_by_digest = sort_by_digest_4_4;
7739 opti_type = OPTI_TYPE_ZERO_BYTE;
7740 dgst_pos0 = 0;
7741 dgst_pos1 = 1;
7742 dgst_pos2 = 2;
7743 dgst_pos3 = 3;
7744 break;
7745
7746 case 900: hash_type = HASH_TYPE_MD4;
7747 salt_type = SALT_TYPE_NONE;
7748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7749 opts_type = OPTS_TYPE_PT_GENERATE_LE
7750 | OPTS_TYPE_PT_ADD80
7751 | OPTS_TYPE_PT_ADDBITS14;
7752 kern_type = KERN_TYPE_MD4;
7753 dgst_size = DGST_SIZE_4_4;
7754 parse_func = md4_parse_hash;
7755 sort_by_digest = sort_by_digest_4_4;
7756 opti_type = OPTI_TYPE_ZERO_BYTE
7757 | OPTI_TYPE_PRECOMPUTE_INIT
7758 | OPTI_TYPE_PRECOMPUTE_MERKLE
7759 | OPTI_TYPE_MEET_IN_MIDDLE
7760 | OPTI_TYPE_EARLY_SKIP
7761 | OPTI_TYPE_NOT_ITERATED
7762 | OPTI_TYPE_NOT_SALTED
7763 | OPTI_TYPE_RAW_HASH;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 3;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 1;
7768 break;
7769
7770 case 1000: hash_type = HASH_TYPE_MD4;
7771 salt_type = SALT_TYPE_NONE;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_LE
7774 | OPTS_TYPE_PT_ADD80
7775 | OPTS_TYPE_PT_ADDBITS14
7776 | OPTS_TYPE_PT_UNICODE;
7777 kern_type = KERN_TYPE_MD4_PWU;
7778 dgst_size = DGST_SIZE_4_4;
7779 parse_func = md4_parse_hash;
7780 sort_by_digest = sort_by_digest_4_4;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_PRECOMPUTE_INIT
7783 | OPTI_TYPE_PRECOMPUTE_MERKLE
7784 | OPTI_TYPE_MEET_IN_MIDDLE
7785 | OPTI_TYPE_EARLY_SKIP
7786 | OPTI_TYPE_NOT_ITERATED
7787 | OPTI_TYPE_NOT_SALTED
7788 | OPTI_TYPE_RAW_HASH;
7789 dgst_pos0 = 0;
7790 dgst_pos1 = 3;
7791 dgst_pos2 = 2;
7792 dgst_pos3 = 1;
7793 break;
7794
7795 case 1100: hash_type = HASH_TYPE_MD4;
7796 salt_type = SALT_TYPE_INTERN;
7797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7798 opts_type = OPTS_TYPE_PT_GENERATE_LE
7799 | OPTS_TYPE_PT_ADD80
7800 | OPTS_TYPE_PT_ADDBITS14
7801 | OPTS_TYPE_PT_UNICODE
7802 | OPTS_TYPE_ST_ADD80
7803 | OPTS_TYPE_ST_UNICODE
7804 | OPTS_TYPE_ST_LOWER;
7805 kern_type = KERN_TYPE_MD44_PWUSLT;
7806 dgst_size = DGST_SIZE_4_4;
7807 parse_func = dcc_parse_hash;
7808 sort_by_digest = sort_by_digest_4_4;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED;
7814 dgst_pos0 = 0;
7815 dgst_pos1 = 3;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 1;
7818 break;
7819
7820 case 1400: hash_type = HASH_TYPE_SHA256;
7821 salt_type = SALT_TYPE_NONE;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_BE
7824 | OPTS_TYPE_PT_ADD80
7825 | OPTS_TYPE_PT_ADDBITS15;
7826 kern_type = KERN_TYPE_SHA256;
7827 dgst_size = DGST_SIZE_4_8;
7828 parse_func = sha256_parse_hash;
7829 sort_by_digest = sort_by_digest_4_8;
7830 opti_type = OPTI_TYPE_ZERO_BYTE
7831 | OPTI_TYPE_PRECOMPUTE_INIT
7832 | OPTI_TYPE_PRECOMPUTE_MERKLE
7833 | OPTI_TYPE_EARLY_SKIP
7834 | OPTI_TYPE_NOT_ITERATED
7835 | OPTI_TYPE_NOT_SALTED
7836 | OPTI_TYPE_RAW_HASH;
7837 dgst_pos0 = 3;
7838 dgst_pos1 = 7;
7839 dgst_pos2 = 2;
7840 dgst_pos3 = 6;
7841 break;
7842
7843 case 1410: hash_type = HASH_TYPE_SHA256;
7844 salt_type = SALT_TYPE_INTERN;
7845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7846 opts_type = OPTS_TYPE_PT_GENERATE_BE
7847 | OPTS_TYPE_ST_ADD80
7848 | OPTS_TYPE_ST_ADDBITS15;
7849 kern_type = KERN_TYPE_SHA256_PWSLT;
7850 dgst_size = DGST_SIZE_4_8;
7851 parse_func = sha256s_parse_hash;
7852 sort_by_digest = sort_by_digest_4_8;
7853 opti_type = OPTI_TYPE_ZERO_BYTE
7854 | OPTI_TYPE_PRECOMPUTE_INIT
7855 | OPTI_TYPE_PRECOMPUTE_MERKLE
7856 | OPTI_TYPE_EARLY_SKIP
7857 | OPTI_TYPE_NOT_ITERATED
7858 | OPTI_TYPE_APPENDED_SALT
7859 | OPTI_TYPE_RAW_HASH;
7860 dgst_pos0 = 3;
7861 dgst_pos1 = 7;
7862 dgst_pos2 = 2;
7863 dgst_pos3 = 6;
7864 break;
7865
7866 case 1420: hash_type = HASH_TYPE_SHA256;
7867 salt_type = SALT_TYPE_INTERN;
7868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7869 opts_type = OPTS_TYPE_PT_GENERATE_BE
7870 | OPTS_TYPE_PT_ADD80
7871 | OPTS_TYPE_PT_ADDBITS15;
7872 kern_type = KERN_TYPE_SHA256_SLTPW;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = sha256s_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_EARLY_SKIP
7880 | OPTI_TYPE_NOT_ITERATED
7881 | OPTI_TYPE_PREPENDED_SALT
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 3;
7884 dgst_pos1 = 7;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 6;
7887 break;
7888
7889 case 1421: hash_type = HASH_TYPE_SHA256;
7890 salt_type = SALT_TYPE_EMBEDDED;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_PT_ADD80
7894 | OPTS_TYPE_PT_ADDBITS15;
7895 kern_type = KERN_TYPE_SHA256_SLTPW;
7896 dgst_size = DGST_SIZE_4_8;
7897 parse_func = hmailserver_parse_hash;
7898 sort_by_digest = sort_by_digest_4_8;
7899 opti_type = OPTI_TYPE_ZERO_BYTE
7900 | OPTI_TYPE_PRECOMPUTE_INIT
7901 | OPTI_TYPE_PRECOMPUTE_MERKLE
7902 | OPTI_TYPE_EARLY_SKIP
7903 | OPTI_TYPE_NOT_ITERATED
7904 | OPTI_TYPE_PREPENDED_SALT
7905 | OPTI_TYPE_RAW_HASH;
7906 dgst_pos0 = 3;
7907 dgst_pos1 = 7;
7908 dgst_pos2 = 2;
7909 dgst_pos3 = 6;
7910 break;
7911
7912 case 1430: hash_type = HASH_TYPE_SHA256;
7913 salt_type = SALT_TYPE_INTERN;
7914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_BE
7916 | OPTS_TYPE_PT_UNICODE
7917 | OPTS_TYPE_ST_ADD80
7918 | OPTS_TYPE_ST_ADDBITS15;
7919 kern_type = KERN_TYPE_SHA256_PWUSLT;
7920 dgst_size = DGST_SIZE_4_8;
7921 parse_func = sha256s_parse_hash;
7922 sort_by_digest = sort_by_digest_4_8;
7923 opti_type = OPTI_TYPE_ZERO_BYTE
7924 | OPTI_TYPE_PRECOMPUTE_INIT
7925 | OPTI_TYPE_PRECOMPUTE_MERKLE
7926 | OPTI_TYPE_EARLY_SKIP
7927 | OPTI_TYPE_NOT_ITERATED
7928 | OPTI_TYPE_APPENDED_SALT
7929 | OPTI_TYPE_RAW_HASH;
7930 dgst_pos0 = 3;
7931 dgst_pos1 = 7;
7932 dgst_pos2 = 2;
7933 dgst_pos3 = 6;
7934 break;
7935
7936 case 1440: hash_type = HASH_TYPE_SHA256;
7937 salt_type = SALT_TYPE_INTERN;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_ADD80
7941 | OPTS_TYPE_PT_ADDBITS15
7942 | OPTS_TYPE_PT_UNICODE;
7943 kern_type = KERN_TYPE_SHA256_SLTPWU;
7944 dgst_size = DGST_SIZE_4_8;
7945 parse_func = sha256s_parse_hash;
7946 sort_by_digest = sort_by_digest_4_8;
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_PRECOMPUTE_INIT
7949 | OPTI_TYPE_PRECOMPUTE_MERKLE
7950 | OPTI_TYPE_EARLY_SKIP
7951 | OPTI_TYPE_NOT_ITERATED
7952 | OPTI_TYPE_PREPENDED_SALT
7953 | OPTI_TYPE_RAW_HASH;
7954 dgst_pos0 = 3;
7955 dgst_pos1 = 7;
7956 dgst_pos2 = 2;
7957 dgst_pos3 = 6;
7958 break;
7959
7960 case 1441: hash_type = HASH_TYPE_SHA256;
7961 salt_type = SALT_TYPE_EMBEDDED;
7962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7963 opts_type = OPTS_TYPE_PT_GENERATE_BE
7964 | OPTS_TYPE_PT_ADD80
7965 | OPTS_TYPE_PT_ADDBITS15
7966 | OPTS_TYPE_PT_UNICODE
7967 | OPTS_TYPE_ST_BASE64;
7968 kern_type = KERN_TYPE_SHA256_SLTPWU;
7969 dgst_size = DGST_SIZE_4_8;
7970 parse_func = episerver4_parse_hash;
7971 sort_by_digest = sort_by_digest_4_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_PREPENDED_SALT
7978 | OPTI_TYPE_RAW_HASH;
7979 dgst_pos0 = 3;
7980 dgst_pos1 = 7;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 6;
7983 break;
7984
7985 case 1450: hash_type = HASH_TYPE_SHA256;
7986 salt_type = SALT_TYPE_INTERN;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_ST_ADD80;
7990 kern_type = KERN_TYPE_HMACSHA256_PW;
7991 dgst_size = DGST_SIZE_4_8;
7992 parse_func = hmacsha256_parse_hash;
7993 sort_by_digest = sort_by_digest_4_8;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_NOT_ITERATED;
7996 dgst_pos0 = 3;
7997 dgst_pos1 = 7;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 6;
8000 break;
8001
8002 case 1460: hash_type = HASH_TYPE_SHA256;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_BE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS15;
8008 kern_type = KERN_TYPE_HMACSHA256_SLT;
8009 dgst_size = DGST_SIZE_4_8;
8010 parse_func = hmacsha256_parse_hash;
8011 sort_by_digest = sort_by_digest_4_8;
8012 opti_type = OPTI_TYPE_ZERO_BYTE
8013 | OPTI_TYPE_NOT_ITERATED;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 7;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 6;
8018 break;
8019
8020 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8021 salt_type = SALT_TYPE_EMBEDDED;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_LE
8024 | OPTS_TYPE_PT_BITSLICE;
8025 kern_type = KERN_TYPE_DESCRYPT;
8026 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8027 parse_func = descrypt_parse_hash;
8028 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8031 dgst_pos0 = 0;
8032 dgst_pos1 = 1;
8033 dgst_pos2 = 2;
8034 dgst_pos3 = 3;
8035 break;
8036
8037 case 1600: hash_type = HASH_TYPE_MD5;
8038 salt_type = SALT_TYPE_EMBEDDED;
8039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8041 kern_type = KERN_TYPE_APR1CRYPT;
8042 dgst_size = DGST_SIZE_4_4;
8043 parse_func = md5apr1_parse_hash;
8044 sort_by_digest = sort_by_digest_4_4;
8045 opti_type = OPTI_TYPE_ZERO_BYTE;
8046 dgst_pos0 = 0;
8047 dgst_pos1 = 1;
8048 dgst_pos2 = 2;
8049 dgst_pos3 = 3;
8050 break;
8051
8052 case 1700: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_NONE;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_ADD80
8057 | OPTS_TYPE_PT_ADDBITS15;
8058 kern_type = KERN_TYPE_SHA512;
8059 dgst_size = DGST_SIZE_8_8;
8060 parse_func = sha512_parse_hash;
8061 sort_by_digest = sort_by_digest_8_8;
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_PRECOMPUTE_INIT
8064 | OPTI_TYPE_PRECOMPUTE_MERKLE
8065 | OPTI_TYPE_EARLY_SKIP
8066 | OPTI_TYPE_NOT_ITERATED
8067 | OPTI_TYPE_NOT_SALTED
8068 | OPTI_TYPE_USES_BITS_64
8069 | OPTI_TYPE_RAW_HASH;
8070 dgst_pos0 = 14;
8071 dgst_pos1 = 15;
8072 dgst_pos2 = 6;
8073 dgst_pos3 = 7;
8074 break;
8075
8076 case 1710: hash_type = HASH_TYPE_SHA512;
8077 salt_type = SALT_TYPE_INTERN;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_ST_ADD80
8081 | OPTS_TYPE_ST_ADDBITS15;
8082 kern_type = KERN_TYPE_SHA512_PWSLT;
8083 dgst_size = DGST_SIZE_8_8;
8084 parse_func = sha512s_parse_hash;
8085 sort_by_digest = sort_by_digest_8_8;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_PRECOMPUTE_INIT
8088 | OPTI_TYPE_PRECOMPUTE_MERKLE
8089 | OPTI_TYPE_EARLY_SKIP
8090 | OPTI_TYPE_NOT_ITERATED
8091 | OPTI_TYPE_APPENDED_SALT
8092 | OPTI_TYPE_USES_BITS_64
8093 | OPTI_TYPE_RAW_HASH;
8094 dgst_pos0 = 14;
8095 dgst_pos1 = 15;
8096 dgst_pos2 = 6;
8097 dgst_pos3 = 7;
8098 break;
8099
8100 case 1711: hash_type = HASH_TYPE_SHA512;
8101 salt_type = SALT_TYPE_EMBEDDED;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_BE
8104 | OPTS_TYPE_ST_ADD80
8105 | OPTS_TYPE_ST_ADDBITS15;
8106 kern_type = KERN_TYPE_SHA512_PWSLT;
8107 dgst_size = DGST_SIZE_8_8;
8108 parse_func = sha512b64s_parse_hash;
8109 sort_by_digest = sort_by_digest_8_8;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP
8114 | OPTI_TYPE_NOT_ITERATED
8115 | OPTI_TYPE_APPENDED_SALT
8116 | OPTI_TYPE_USES_BITS_64
8117 | OPTI_TYPE_RAW_HASH;
8118 dgst_pos0 = 14;
8119 dgst_pos1 = 15;
8120 dgst_pos2 = 6;
8121 dgst_pos3 = 7;
8122 break;
8123
8124 case 1720: hash_type = HASH_TYPE_SHA512;
8125 salt_type = SALT_TYPE_INTERN;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_PT_ADD80
8129 | OPTS_TYPE_PT_ADDBITS15;
8130 kern_type = KERN_TYPE_SHA512_SLTPW;
8131 dgst_size = DGST_SIZE_8_8;
8132 parse_func = sha512s_parse_hash;
8133 sort_by_digest = sort_by_digest_8_8;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_PREPENDED_SALT
8140 | OPTI_TYPE_USES_BITS_64
8141 | OPTI_TYPE_RAW_HASH;
8142 dgst_pos0 = 14;
8143 dgst_pos1 = 15;
8144 dgst_pos2 = 6;
8145 dgst_pos3 = 7;
8146 break;
8147
8148 case 1722: hash_type = HASH_TYPE_SHA512;
8149 salt_type = SALT_TYPE_EMBEDDED;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_BE
8152 | OPTS_TYPE_PT_ADD80
8153 | OPTS_TYPE_PT_ADDBITS15
8154 | OPTS_TYPE_ST_HEX;
8155 kern_type = KERN_TYPE_SHA512_SLTPW;
8156 dgst_size = DGST_SIZE_8_8;
8157 parse_func = osx512_parse_hash;
8158 sort_by_digest = sort_by_digest_8_8;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_PREPENDED_SALT
8165 | OPTI_TYPE_USES_BITS_64
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 14;
8168 dgst_pos1 = 15;
8169 dgst_pos2 = 6;
8170 dgst_pos3 = 7;
8171 break;
8172
8173 case 1730: hash_type = HASH_TYPE_SHA512;
8174 salt_type = SALT_TYPE_INTERN;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_BE
8177 | OPTS_TYPE_PT_UNICODE
8178 | OPTS_TYPE_ST_ADD80
8179 | OPTS_TYPE_ST_ADDBITS15;
8180 kern_type = KERN_TYPE_SHA512_PWSLTU;
8181 dgst_size = DGST_SIZE_8_8;
8182 parse_func = sha512s_parse_hash;
8183 sort_by_digest = sort_by_digest_8_8;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_PRECOMPUTE_INIT
8186 | OPTI_TYPE_PRECOMPUTE_MERKLE
8187 | OPTI_TYPE_EARLY_SKIP
8188 | OPTI_TYPE_NOT_ITERATED
8189 | OPTI_TYPE_APPENDED_SALT
8190 | OPTI_TYPE_USES_BITS_64
8191 | OPTI_TYPE_RAW_HASH;
8192 dgst_pos0 = 14;
8193 dgst_pos1 = 15;
8194 dgst_pos2 = 6;
8195 dgst_pos3 = 7;
8196 break;
8197
8198 case 1731: hash_type = HASH_TYPE_SHA512;
8199 salt_type = SALT_TYPE_EMBEDDED;
8200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_BE
8202 | OPTS_TYPE_PT_UNICODE
8203 | OPTS_TYPE_ST_ADD80
8204 | OPTS_TYPE_ST_ADDBITS15
8205 | OPTS_TYPE_ST_HEX;
8206 kern_type = KERN_TYPE_SHA512_PWSLTU;
8207 dgst_size = DGST_SIZE_8_8;
8208 parse_func = mssql2012_parse_hash;
8209 sort_by_digest = sort_by_digest_8_8;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_PRECOMPUTE_INIT
8212 | OPTI_TYPE_PRECOMPUTE_MERKLE
8213 | OPTI_TYPE_EARLY_SKIP
8214 | OPTI_TYPE_NOT_ITERATED
8215 | OPTI_TYPE_APPENDED_SALT
8216 | OPTI_TYPE_USES_BITS_64
8217 | OPTI_TYPE_RAW_HASH;
8218 dgst_pos0 = 14;
8219 dgst_pos1 = 15;
8220 dgst_pos2 = 6;
8221 dgst_pos3 = 7;
8222 break;
8223
8224 case 1740: hash_type = HASH_TYPE_SHA512;
8225 salt_type = SALT_TYPE_INTERN;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_BE
8228 | OPTS_TYPE_PT_ADD80
8229 | OPTS_TYPE_PT_ADDBITS15
8230 | OPTS_TYPE_PT_UNICODE;
8231 kern_type = KERN_TYPE_SHA512_SLTPWU;
8232 dgst_size = DGST_SIZE_8_8;
8233 parse_func = sha512s_parse_hash;
8234 sort_by_digest = sort_by_digest_8_8;
8235 opti_type = OPTI_TYPE_ZERO_BYTE
8236 | OPTI_TYPE_PRECOMPUTE_INIT
8237 | OPTI_TYPE_PRECOMPUTE_MERKLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_PREPENDED_SALT
8241 | OPTI_TYPE_USES_BITS_64
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 14;
8244 dgst_pos1 = 15;
8245 dgst_pos2 = 6;
8246 dgst_pos3 = 7;
8247 break;
8248
8249 case 1750: hash_type = HASH_TYPE_SHA512;
8250 salt_type = SALT_TYPE_INTERN;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_BE
8253 | OPTS_TYPE_ST_ADD80;
8254 kern_type = KERN_TYPE_HMACSHA512_PW;
8255 dgst_size = DGST_SIZE_8_8;
8256 parse_func = hmacsha512_parse_hash;
8257 sort_by_digest = sort_by_digest_8_8;
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_USES_BITS_64
8260 | OPTI_TYPE_NOT_ITERATED;
8261 dgst_pos0 = 14;
8262 dgst_pos1 = 15;
8263 dgst_pos2 = 6;
8264 dgst_pos3 = 7;
8265 break;
8266
8267 case 1760: hash_type = HASH_TYPE_SHA512;
8268 salt_type = SALT_TYPE_INTERN;
8269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8270 opts_type = OPTS_TYPE_PT_GENERATE_BE
8271 | OPTS_TYPE_PT_ADD80
8272 | OPTS_TYPE_PT_ADDBITS15;
8273 kern_type = KERN_TYPE_HMACSHA512_SLT;
8274 dgst_size = DGST_SIZE_8_8;
8275 parse_func = hmacsha512_parse_hash;
8276 sort_by_digest = sort_by_digest_8_8;
8277 opti_type = OPTI_TYPE_ZERO_BYTE
8278 | OPTI_TYPE_USES_BITS_64
8279 | OPTI_TYPE_NOT_ITERATED;
8280 dgst_pos0 = 14;
8281 dgst_pos1 = 15;
8282 dgst_pos2 = 6;
8283 dgst_pos3 = 7;
8284 break;
8285
8286 case 1800: hash_type = HASH_TYPE_SHA512;
8287 salt_type = SALT_TYPE_EMBEDDED;
8288 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8290 kern_type = KERN_TYPE_SHA512CRYPT;
8291 dgst_size = DGST_SIZE_8_8;
8292 parse_func = sha512crypt_parse_hash;
8293 sort_by_digest = sort_by_digest_8_8;
8294 opti_type = OPTI_TYPE_ZERO_BYTE
8295 | OPTI_TYPE_USES_BITS_64;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 1;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 3;
8300 break;
8301
8302 case 2100: hash_type = HASH_TYPE_DCC2;
8303 salt_type = SALT_TYPE_EMBEDDED;
8304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8306 | OPTS_TYPE_ST_LOWER
8307 | OPTS_TYPE_ST_UNICODE;
8308 kern_type = KERN_TYPE_DCC2;
8309 dgst_size = DGST_SIZE_4_4;
8310 parse_func = dcc2_parse_hash;
8311 sort_by_digest = sort_by_digest_4_4;
8312 opti_type = OPTI_TYPE_ZERO_BYTE
8313 | OPTI_TYPE_SLOW_HASH_SIMD;
8314 dgst_pos0 = 0;
8315 dgst_pos1 = 1;
8316 dgst_pos2 = 2;
8317 dgst_pos3 = 3;
8318 break;
8319
8320 case 2400: hash_type = HASH_TYPE_MD5;
8321 salt_type = SALT_TYPE_NONE;
8322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8324 kern_type = KERN_TYPE_MD5PIX;
8325 dgst_size = DGST_SIZE_4_4;
8326 parse_func = md5pix_parse_hash;
8327 sort_by_digest = sort_by_digest_4_4;
8328 opti_type = OPTI_TYPE_ZERO_BYTE
8329 | OPTI_TYPE_PRECOMPUTE_INIT
8330 | OPTI_TYPE_PRECOMPUTE_MERKLE
8331 | OPTI_TYPE_EARLY_SKIP
8332 | OPTI_TYPE_NOT_ITERATED
8333 | OPTI_TYPE_NOT_SALTED;
8334 dgst_pos0 = 0;
8335 dgst_pos1 = 3;
8336 dgst_pos2 = 2;
8337 dgst_pos3 = 1;
8338 break;
8339
8340 case 2410: hash_type = HASH_TYPE_MD5;
8341 salt_type = SALT_TYPE_INTERN;
8342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8343 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8344 kern_type = KERN_TYPE_MD5ASA;
8345 dgst_size = DGST_SIZE_4_4;
8346 parse_func = md5asa_parse_hash;
8347 sort_by_digest = sort_by_digest_4_4;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP
8352 | OPTI_TYPE_NOT_ITERATED;
8353 dgst_pos0 = 0;
8354 dgst_pos1 = 3;
8355 dgst_pos2 = 2;
8356 dgst_pos3 = 1;
8357 break;
8358
8359 case 2500: hash_type = HASH_TYPE_WPA;
8360 salt_type = SALT_TYPE_EMBEDDED;
8361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8362 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8363 kern_type = KERN_TYPE_WPA;
8364 dgst_size = DGST_SIZE_4_4;
8365 parse_func = wpa_parse_hash;
8366 sort_by_digest = sort_by_digest_4_4;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_SLOW_HASH_SIMD;
8369 dgst_pos0 = 0;
8370 dgst_pos1 = 1;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 3;
8373 break;
8374
8375 case 2600: hash_type = HASH_TYPE_MD5;
8376 salt_type = SALT_TYPE_VIRTUAL;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_LE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS14
8381 | OPTS_TYPE_ST_ADD80;
8382 kern_type = KERN_TYPE_MD55_PWSLT1;
8383 dgst_size = DGST_SIZE_4_4;
8384 parse_func = md5md5_parse_hash;
8385 sort_by_digest = sort_by_digest_4_4;
8386 opti_type = OPTI_TYPE_ZERO_BYTE
8387 | OPTI_TYPE_PRECOMPUTE_INIT
8388 | OPTI_TYPE_PRECOMPUTE_MERKLE
8389 | OPTI_TYPE_EARLY_SKIP;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 2611: hash_type = HASH_TYPE_MD5;
8397 salt_type = SALT_TYPE_INTERN;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE
8400 | OPTS_TYPE_PT_ADD80
8401 | OPTS_TYPE_PT_ADDBITS14
8402 | OPTS_TYPE_ST_ADD80;
8403 kern_type = KERN_TYPE_MD55_PWSLT1;
8404 dgst_size = DGST_SIZE_4_4;
8405 parse_func = vb3_parse_hash;
8406 sort_by_digest = sort_by_digest_4_4;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_PRECOMPUTE_INIT
8409 | OPTI_TYPE_PRECOMPUTE_MERKLE
8410 | OPTI_TYPE_EARLY_SKIP;
8411 dgst_pos0 = 0;
8412 dgst_pos1 = 3;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 1;
8415 break;
8416
8417 case 2612: hash_type = HASH_TYPE_MD5;
8418 salt_type = SALT_TYPE_EMBEDDED;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_LE
8421 | OPTS_TYPE_PT_ADD80
8422 | OPTS_TYPE_PT_ADDBITS14
8423 | OPTS_TYPE_ST_ADD80
8424 | OPTS_TYPE_ST_HEX;
8425 kern_type = KERN_TYPE_MD55_PWSLT1;
8426 dgst_size = DGST_SIZE_4_4;
8427 parse_func = phps_parse_hash;
8428 sort_by_digest = sort_by_digest_4_4;
8429 opti_type = OPTI_TYPE_ZERO_BYTE
8430 | OPTI_TYPE_PRECOMPUTE_INIT
8431 | OPTI_TYPE_PRECOMPUTE_MERKLE
8432 | OPTI_TYPE_EARLY_SKIP;
8433 dgst_pos0 = 0;
8434 dgst_pos1 = 3;
8435 dgst_pos2 = 2;
8436 dgst_pos3 = 1;
8437 break;
8438
8439 case 2711: hash_type = HASH_TYPE_MD5;
8440 salt_type = SALT_TYPE_INTERN;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_LE
8443 | OPTS_TYPE_PT_ADD80
8444 | OPTS_TYPE_PT_ADDBITS14
8445 | OPTS_TYPE_ST_ADD80;
8446 kern_type = KERN_TYPE_MD55_PWSLT2;
8447 dgst_size = DGST_SIZE_4_4;
8448 parse_func = vb30_parse_hash;
8449 sort_by_digest = sort_by_digest_4_4;
8450 opti_type = OPTI_TYPE_ZERO_BYTE
8451 | OPTI_TYPE_PRECOMPUTE_INIT
8452 | OPTI_TYPE_EARLY_SKIP;
8453 dgst_pos0 = 0;
8454 dgst_pos1 = 3;
8455 dgst_pos2 = 2;
8456 dgst_pos3 = 1;
8457 break;
8458
8459 case 2811: hash_type = HASH_TYPE_MD5;
8460 salt_type = SALT_TYPE_INTERN;
8461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8462 opts_type = OPTS_TYPE_PT_GENERATE_LE
8463 | OPTS_TYPE_PT_ADD80
8464 | OPTS_TYPE_PT_ADDBITS14;
8465 kern_type = KERN_TYPE_MD55_SLTPW;
8466 dgst_size = DGST_SIZE_4_4;
8467 parse_func = ipb2_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_EARLY_SKIP;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 3;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 1;
8476 break;
8477
8478 case 3000: hash_type = HASH_TYPE_LM;
8479 salt_type = SALT_TYPE_NONE;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE
8482 | OPTS_TYPE_PT_UPPER
8483 | OPTS_TYPE_PT_BITSLICE;
8484 kern_type = KERN_TYPE_LM;
8485 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8486 parse_func = lm_parse_hash;
8487 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8488 opti_type = OPTI_TYPE_ZERO_BYTE
8489 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 1;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 3;
8494 break;
8495
8496 case 3100: hash_type = HASH_TYPE_ORACLEH;
8497 salt_type = SALT_TYPE_INTERN;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE
8500 | OPTS_TYPE_PT_UPPER
8501 | OPTS_TYPE_ST_UPPER;
8502 kern_type = KERN_TYPE_ORACLEH;
8503 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8504 parse_func = oracleh_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8506 opti_type = OPTI_TYPE_ZERO_BYTE;
8507 dgst_pos0 = 0;
8508 dgst_pos1 = 1;
8509 dgst_pos2 = 2;
8510 dgst_pos3 = 3;
8511 break;
8512
8513 case 3200: hash_type = HASH_TYPE_BCRYPT;
8514 salt_type = SALT_TYPE_EMBEDDED;
8515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8516 opts_type = OPTS_TYPE_PT_GENERATE_LE
8517 | OPTS_TYPE_ST_GENERATE_LE;
8518 kern_type = KERN_TYPE_BCRYPT;
8519 dgst_size = DGST_SIZE_4_6;
8520 parse_func = bcrypt_parse_hash;
8521 sort_by_digest = sort_by_digest_4_6;
8522 opti_type = OPTI_TYPE_ZERO_BYTE;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 1;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 3;
8527 break;
8528
8529 case 3710: hash_type = HASH_TYPE_MD5;
8530 salt_type = SALT_TYPE_INTERN;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_LE
8533 | OPTS_TYPE_PT_ADD80
8534 | OPTS_TYPE_PT_ADDBITS14;
8535 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8536 dgst_size = DGST_SIZE_4_4;
8537 parse_func = md5s_parse_hash;
8538 sort_by_digest = sort_by_digest_4_4;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_PRECOMPUTE_MERKLE
8542 | OPTI_TYPE_EARLY_SKIP;
8543 dgst_pos0 = 0;
8544 dgst_pos1 = 3;
8545 dgst_pos2 = 2;
8546 dgst_pos3 = 1;
8547 break;
8548
8549 case 3711: hash_type = HASH_TYPE_MD5;
8550 salt_type = SALT_TYPE_EMBEDDED;
8551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8552 opts_type = OPTS_TYPE_PT_GENERATE_LE
8553 | OPTS_TYPE_PT_ADD80
8554 | OPTS_TYPE_PT_ADDBITS14;
8555 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8556 dgst_size = DGST_SIZE_4_4;
8557 parse_func = mediawiki_b_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4;
8559 opti_type = OPTI_TYPE_ZERO_BYTE
8560 | OPTI_TYPE_PRECOMPUTE_INIT
8561 | OPTI_TYPE_PRECOMPUTE_MERKLE
8562 | OPTI_TYPE_EARLY_SKIP;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 3;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 1;
8567 break;
8568
8569 case 3800: hash_type = HASH_TYPE_MD5;
8570 salt_type = SALT_TYPE_INTERN;
8571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE
8573 | OPTS_TYPE_ST_ADDBITS14;
8574 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8575 dgst_size = DGST_SIZE_4_4;
8576 parse_func = md5s_parse_hash;
8577 sort_by_digest = sort_by_digest_4_4;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_ITERATED
8583 | OPTI_TYPE_RAW_HASH;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 3;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 1;
8588 break;
8589
8590 case 4300: hash_type = HASH_TYPE_MD5;
8591 salt_type = SALT_TYPE_VIRTUAL;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_LE
8594 | OPTS_TYPE_PT_ADD80
8595 | OPTS_TYPE_PT_ADDBITS14
8596 | OPTS_TYPE_ST_ADD80;
8597 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8598 dgst_size = DGST_SIZE_4_4;
8599 parse_func = md5md5_parse_hash;
8600 sort_by_digest = sort_by_digest_4_4;
8601 opti_type = OPTI_TYPE_ZERO_BYTE
8602 | OPTI_TYPE_PRECOMPUTE_INIT
8603 | OPTI_TYPE_PRECOMPUTE_MERKLE
8604 | OPTI_TYPE_EARLY_SKIP;
8605 dgst_pos0 = 0;
8606 dgst_pos1 = 3;
8607 dgst_pos2 = 2;
8608 dgst_pos3 = 1;
8609 break;
8610
8611
8612 case 4400: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_NONE;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_BE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS15;
8618 kern_type = KERN_TYPE_MD5_SHA1;
8619 dgst_size = DGST_SIZE_4_4;
8620 parse_func = md5_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 | OPTI_TYPE_NOT_ITERATED
8627 | OPTI_TYPE_NOT_SALTED
8628 | OPTI_TYPE_RAW_HASH;
8629 dgst_pos0 = 0;
8630 dgst_pos1 = 3;
8631 dgst_pos2 = 2;
8632 dgst_pos3 = 1;
8633 break;
8634
8635 case 4500: hash_type = HASH_TYPE_SHA1;
8636 salt_type = SALT_TYPE_NONE;
8637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8638 opts_type = OPTS_TYPE_PT_GENERATE_BE
8639 | OPTS_TYPE_PT_ADD80
8640 | OPTS_TYPE_PT_ADDBITS15;
8641 kern_type = KERN_TYPE_SHA11;
8642 dgst_size = DGST_SIZE_4_5;
8643 parse_func = sha1_parse_hash;
8644 sort_by_digest = sort_by_digest_4_5;
8645 opti_type = OPTI_TYPE_ZERO_BYTE
8646 | OPTI_TYPE_PRECOMPUTE_INIT
8647 | OPTI_TYPE_PRECOMPUTE_MERKLE
8648 | OPTI_TYPE_EARLY_SKIP
8649 | OPTI_TYPE_NOT_SALTED;
8650 dgst_pos0 = 3;
8651 dgst_pos1 = 4;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 1;
8654 break;
8655
8656 case 4700: hash_type = HASH_TYPE_SHA1;
8657 salt_type = SALT_TYPE_NONE;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE
8660 | OPTS_TYPE_PT_ADD80
8661 | OPTS_TYPE_PT_ADDBITS14;
8662 kern_type = KERN_TYPE_SHA1_MD5;
8663 dgst_size = DGST_SIZE_4_5;
8664 parse_func = sha1_parse_hash;
8665 sort_by_digest = sort_by_digest_4_5;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_INIT
8668 | OPTI_TYPE_PRECOMPUTE_MERKLE
8669 | OPTI_TYPE_EARLY_SKIP
8670 | OPTI_TYPE_NOT_ITERATED
8671 | OPTI_TYPE_NOT_SALTED
8672 | OPTI_TYPE_RAW_HASH;
8673 dgst_pos0 = 3;
8674 dgst_pos1 = 4;
8675 dgst_pos2 = 2;
8676 dgst_pos3 = 1;
8677 break;
8678
8679 case 4800: hash_type = HASH_TYPE_MD5;
8680 salt_type = SALT_TYPE_EMBEDDED;
8681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8682 opts_type = OPTS_TYPE_PT_GENERATE_LE
8683 | OPTS_TYPE_PT_ADDBITS14;
8684 kern_type = KERN_TYPE_MD5_CHAP;
8685 dgst_size = DGST_SIZE_4_4;
8686 parse_func = chap_parse_hash;
8687 sort_by_digest = sort_by_digest_4_4;
8688 opti_type = OPTI_TYPE_ZERO_BYTE
8689 | OPTI_TYPE_PRECOMPUTE_INIT
8690 | OPTI_TYPE_PRECOMPUTE_MERKLE
8691 | OPTI_TYPE_MEET_IN_MIDDLE
8692 | OPTI_TYPE_EARLY_SKIP
8693 | OPTI_TYPE_NOT_ITERATED
8694 | OPTI_TYPE_RAW_HASH;
8695 dgst_pos0 = 0;
8696 dgst_pos1 = 3;
8697 dgst_pos2 = 2;
8698 dgst_pos3 = 1;
8699 break;
8700
8701 case 4900: hash_type = HASH_TYPE_SHA1;
8702 salt_type = SALT_TYPE_INTERN;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8705 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8706 dgst_size = DGST_SIZE_4_5;
8707 parse_func = sha1s_parse_hash;
8708 sort_by_digest = sort_by_digest_4_5;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_INIT
8711 | OPTI_TYPE_PRECOMPUTE_MERKLE
8712 | OPTI_TYPE_EARLY_SKIP;
8713 dgst_pos0 = 3;
8714 dgst_pos1 = 4;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719 case 5000: hash_type = HASH_TYPE_KECCAK;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_LE
8723 | OPTS_TYPE_PT_ADD01;
8724 kern_type = KERN_TYPE_KECCAK;
8725 dgst_size = DGST_SIZE_8_25;
8726 parse_func = keccak_parse_hash;
8727 sort_by_digest = sort_by_digest_8_25;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_USES_BITS_64
8730 | OPTI_TYPE_RAW_HASH;
8731 dgst_pos0 = 2;
8732 dgst_pos1 = 3;
8733 dgst_pos2 = 4;
8734 dgst_pos3 = 5;
8735 break;
8736
8737 case 5100: hash_type = HASH_TYPE_MD5H;
8738 salt_type = SALT_TYPE_NONE;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE
8741 | OPTS_TYPE_PT_ADD80
8742 | OPTS_TYPE_PT_ADDBITS14;
8743 kern_type = KERN_TYPE_MD5H;
8744 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8745 parse_func = md5half_parse_hash;
8746 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_RAW_HASH;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 1;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 3;
8753 break;
8754
8755 case 5200: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8759 kern_type = KERN_TYPE_PSAFE3;
8760 dgst_size = DGST_SIZE_4_8;
8761 parse_func = psafe3_parse_hash;
8762 sort_by_digest = sort_by_digest_4_8;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 5300: hash_type = HASH_TYPE_MD5;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE
8774 | OPTS_TYPE_ST_ADD80;
8775 kern_type = KERN_TYPE_IKEPSK_MD5;
8776 dgst_size = DGST_SIZE_4_4;
8777 parse_func = ikepsk_md5_parse_hash;
8778 sort_by_digest = sort_by_digest_4_4;
8779 opti_type = OPTI_TYPE_ZERO_BYTE;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 3;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 1;
8784 break;
8785
8786 case 5400: hash_type = HASH_TYPE_SHA1;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_BE
8790 | OPTS_TYPE_ST_ADD80;
8791 kern_type = KERN_TYPE_IKEPSK_SHA1;
8792 dgst_size = DGST_SIZE_4_5;
8793 parse_func = ikepsk_sha1_parse_hash;
8794 sort_by_digest = sort_by_digest_4_5;
8795 opti_type = OPTI_TYPE_ZERO_BYTE;
8796 dgst_pos0 = 3;
8797 dgst_pos1 = 4;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 1;
8800 break;
8801
8802 case 5500: hash_type = HASH_TYPE_NETNTLM;
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_ADD80
8807 | OPTS_TYPE_PT_ADDBITS14
8808 | OPTS_TYPE_PT_UNICODE
8809 | OPTS_TYPE_ST_HEX;
8810 kern_type = KERN_TYPE_NETNTLMv1;
8811 dgst_size = DGST_SIZE_4_4;
8812 parse_func = netntlmv1_parse_hash;
8813 sort_by_digest = sort_by_digest_4_4;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8816 dgst_pos0 = 0;
8817 dgst_pos1 = 1;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 3;
8820 break;
8821
8822 case 5600: hash_type = HASH_TYPE_MD5;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE
8826 | OPTS_TYPE_PT_ADD80
8827 | OPTS_TYPE_PT_ADDBITS14
8828 | OPTS_TYPE_PT_UNICODE;
8829 kern_type = KERN_TYPE_NETNTLMv2;
8830 dgst_size = DGST_SIZE_4_4;
8831 parse_func = netntlmv2_parse_hash;
8832 sort_by_digest = sort_by_digest_4_4;
8833 opti_type = OPTI_TYPE_ZERO_BYTE;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 3;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 1;
8838 break;
8839
8840 case 5700: hash_type = HASH_TYPE_SHA256;
8841 salt_type = SALT_TYPE_NONE;
8842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_BE
8844 | OPTS_TYPE_PT_ADD80
8845 | OPTS_TYPE_PT_ADDBITS15;
8846 kern_type = KERN_TYPE_SHA256;
8847 dgst_size = DGST_SIZE_4_8;
8848 parse_func = cisco4_parse_hash;
8849 sort_by_digest = sort_by_digest_4_8;
8850 opti_type = OPTI_TYPE_ZERO_BYTE
8851 | OPTI_TYPE_PRECOMPUTE_INIT
8852 | OPTI_TYPE_PRECOMPUTE_MERKLE
8853 | OPTI_TYPE_EARLY_SKIP
8854 | OPTI_TYPE_NOT_ITERATED
8855 | OPTI_TYPE_NOT_SALTED
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 3;
8858 dgst_pos1 = 7;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 6;
8861 break;
8862
8863 case 5800: hash_type = HASH_TYPE_SHA1;
8864 salt_type = SALT_TYPE_INTERN;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8867 | OPTS_TYPE_ST_ADD80;
8868 kern_type = KERN_TYPE_ANDROIDPIN;
8869 dgst_size = DGST_SIZE_4_5;
8870 parse_func = androidpin_parse_hash;
8871 sort_by_digest = sort_by_digest_4_5;
8872 opti_type = OPTI_TYPE_ZERO_BYTE;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8880 salt_type = SALT_TYPE_NONE;
8881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE
8883 | OPTS_TYPE_PT_ADD80;
8884 kern_type = KERN_TYPE_RIPEMD160;
8885 dgst_size = DGST_SIZE_4_5;
8886 parse_func = ripemd160_parse_hash;
8887 sort_by_digest = sort_by_digest_4_5;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8896 salt_type = SALT_TYPE_NONE;
8897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_BE
8899 | OPTS_TYPE_PT_ADD80;
8900 kern_type = KERN_TYPE_WHIRLPOOL;
8901 dgst_size = DGST_SIZE_4_16;
8902 parse_func = whirlpool_parse_hash;
8903 sort_by_digest = sort_by_digest_4_16;
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8915 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8916 dgst_size = DGST_SIZE_4_5;
8917 parse_func = truecrypt_parse_hash_2k;
8918 sort_by_digest = sort_by_digest_4_5;
8919 opti_type = OPTI_TYPE_ZERO_BYTE;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8930 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8931 dgst_size = DGST_SIZE_4_5;
8932 parse_func = truecrypt_parse_hash_2k;
8933 sort_by_digest = sort_by_digest_4_5;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8945 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8946 dgst_size = DGST_SIZE_4_5;
8947 parse_func = truecrypt_parse_hash_2k;
8948 sort_by_digest = sort_by_digest_4_5;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6221: hash_type = HASH_TYPE_SHA512;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8960 kern_type = KERN_TYPE_TCSHA512_XTS512;
8961 dgst_size = DGST_SIZE_8_8;
8962 parse_func = truecrypt_parse_hash_1k;
8963 sort_by_digest = sort_by_digest_8_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE
8965 | OPTI_TYPE_USES_BITS_64;
8966 dgst_pos0 = 0;
8967 dgst_pos1 = 1;
8968 dgst_pos2 = 2;
8969 dgst_pos3 = 3;
8970 break;
8971
8972 case 6222: hash_type = HASH_TYPE_SHA512;
8973 salt_type = SALT_TYPE_EMBEDDED;
8974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8975 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8976 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8977 dgst_size = DGST_SIZE_8_8;
8978 parse_func = truecrypt_parse_hash_1k;
8979 sort_by_digest = sort_by_digest_8_8;
8980 opti_type = OPTI_TYPE_ZERO_BYTE
8981 | OPTI_TYPE_USES_BITS_64;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 6223: hash_type = HASH_TYPE_SHA512;
8989 salt_type = SALT_TYPE_EMBEDDED;
8990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8992 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8993 dgst_size = DGST_SIZE_8_8;
8994 parse_func = truecrypt_parse_hash_1k;
8995 sort_by_digest = sort_by_digest_8_8;
8996 opti_type = OPTI_TYPE_ZERO_BYTE
8997 | OPTI_TYPE_USES_BITS_64;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9008 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9009 dgst_size = DGST_SIZE_4_8;
9010 parse_func = truecrypt_parse_hash_1k;
9011 sort_by_digest = sort_by_digest_4_8;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9023 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9024 dgst_size = DGST_SIZE_4_8;
9025 parse_func = truecrypt_parse_hash_1k;
9026 sort_by_digest = sort_by_digest_4_8;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9039 dgst_size = DGST_SIZE_4_8;
9040 parse_func = truecrypt_parse_hash_1k;
9041 sort_by_digest = sort_by_digest_4_8;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9053 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9054 dgst_size = DGST_SIZE_4_5;
9055 parse_func = truecrypt_parse_hash_1k;
9056 sort_by_digest = sort_by_digest_4_5;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9068 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9069 dgst_size = DGST_SIZE_4_5;
9070 parse_func = truecrypt_parse_hash_1k;
9071 sort_by_digest = sort_by_digest_4_5;
9072 opti_type = OPTI_TYPE_ZERO_BYTE;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 1;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 3;
9077 break;
9078
9079 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9083 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = truecrypt_parse_hash_1k;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE;
9088 dgst_pos0 = 0;
9089 dgst_pos1 = 1;
9090 dgst_pos2 = 2;
9091 dgst_pos3 = 3;
9092 break;
9093
9094 case 6300: hash_type = HASH_TYPE_MD5;
9095 salt_type = SALT_TYPE_EMBEDDED;
9096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9097 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9098 kern_type = KERN_TYPE_MD5AIX;
9099 dgst_size = DGST_SIZE_4_4;
9100 parse_func = md5aix_parse_hash;
9101 sort_by_digest = sort_by_digest_4_4;
9102 opti_type = OPTI_TYPE_ZERO_BYTE;
9103 dgst_pos0 = 0;
9104 dgst_pos1 = 1;
9105 dgst_pos2 = 2;
9106 dgst_pos3 = 3;
9107 break;
9108
9109 case 6400: hash_type = HASH_TYPE_SHA256;
9110 salt_type = SALT_TYPE_EMBEDDED;
9111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9112 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9113 kern_type = KERN_TYPE_SHA256AIX;
9114 dgst_size = DGST_SIZE_4_8;
9115 parse_func = sha256aix_parse_hash;
9116 sort_by_digest = sort_by_digest_4_8;
9117 opti_type = OPTI_TYPE_ZERO_BYTE;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 6500: hash_type = HASH_TYPE_SHA512;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9128 kern_type = KERN_TYPE_SHA512AIX;
9129 dgst_size = DGST_SIZE_8_8;
9130 parse_func = sha512aix_parse_hash;
9131 sort_by_digest = sort_by_digest_8_8;
9132 opti_type = OPTI_TYPE_ZERO_BYTE
9133 | OPTI_TYPE_USES_BITS_64;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 6600: hash_type = HASH_TYPE_AES;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9144 kern_type = KERN_TYPE_AGILEKEY;
9145 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9146 parse_func = agilekey_parse_hash;
9147 sort_by_digest = sort_by_digest_4_5;
9148 opti_type = OPTI_TYPE_ZERO_BYTE;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 1;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 3;
9153 break;
9154
9155 case 6700: hash_type = HASH_TYPE_SHA1;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9159 kern_type = KERN_TYPE_SHA1AIX;
9160 dgst_size = DGST_SIZE_4_5;
9161 parse_func = sha1aix_parse_hash;
9162 sort_by_digest = sort_by_digest_4_5;
9163 opti_type = OPTI_TYPE_ZERO_BYTE;
9164 dgst_pos0 = 0;
9165 dgst_pos1 = 1;
9166 dgst_pos2 = 2;
9167 dgst_pos3 = 3;
9168 break;
9169
9170 case 6800: hash_type = HASH_TYPE_AES;
9171 salt_type = SALT_TYPE_EMBEDDED;
9172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9173 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9174 kern_type = KERN_TYPE_LASTPASS;
9175 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9176 parse_func = lastpass_parse_hash;
9177 sort_by_digest = sort_by_digest_4_8;
9178 opti_type = OPTI_TYPE_ZERO_BYTE;
9179 dgst_pos0 = 0;
9180 dgst_pos1 = 1;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 3;
9183 break;
9184
9185 case 6900: hash_type = HASH_TYPE_GOST;
9186 salt_type = SALT_TYPE_NONE;
9187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9189 kern_type = KERN_TYPE_GOST;
9190 dgst_size = DGST_SIZE_4_8;
9191 parse_func = gost_parse_hash;
9192 sort_by_digest = sort_by_digest_4_8;
9193 opti_type = OPTI_TYPE_ZERO_BYTE;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 7100: hash_type = HASH_TYPE_SHA512;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9204 kern_type = KERN_TYPE_PBKDF2_SHA512;
9205 dgst_size = DGST_SIZE_8_16;
9206 parse_func = sha512osx_parse_hash;
9207 sort_by_digest = sort_by_digest_8_16;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_USES_BITS_64
9210 | OPTI_TYPE_SLOW_HASH_SIMD;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 7200: hash_type = HASH_TYPE_SHA512;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_PBKDF2_SHA512;
9222 dgst_size = DGST_SIZE_8_16;
9223 parse_func = sha512grub_parse_hash;
9224 sort_by_digest = sort_by_digest_8_16;
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_USES_BITS_64
9227 | OPTI_TYPE_SLOW_HASH_SIMD;
9228 dgst_pos0 = 0;
9229 dgst_pos1 = 1;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 3;
9232 break;
9233
9234 case 7300: hash_type = HASH_TYPE_SHA1;
9235 salt_type = SALT_TYPE_EMBEDDED;
9236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_BE
9238 | OPTS_TYPE_ST_ADD80
9239 | OPTS_TYPE_ST_ADDBITS15;
9240 kern_type = KERN_TYPE_RAKP;
9241 dgst_size = DGST_SIZE_4_5;
9242 parse_func = rakp_parse_hash;
9243 sort_by_digest = sort_by_digest_4_5;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_NOT_ITERATED;
9246 dgst_pos0 = 3;
9247 dgst_pos1 = 4;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 1;
9250 break;
9251
9252 case 7400: hash_type = HASH_TYPE_SHA256;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9256 kern_type = KERN_TYPE_SHA256CRYPT;
9257 dgst_size = DGST_SIZE_4_8;
9258 parse_func = sha256crypt_parse_hash;
9259 sort_by_digest = sort_by_digest_4_8;
9260 opti_type = OPTI_TYPE_ZERO_BYTE;
9261 dgst_pos0 = 0;
9262 dgst_pos1 = 1;
9263 dgst_pos2 = 2;
9264 dgst_pos3 = 3;
9265 break;
9266
9267 case 7500: hash_type = HASH_TYPE_KRB5PA;
9268 salt_type = SALT_TYPE_EMBEDDED;
9269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9271 kern_type = KERN_TYPE_KRB5PA;
9272 dgst_size = DGST_SIZE_4_4;
9273 parse_func = krb5pa_parse_hash;
9274 sort_by_digest = sort_by_digest_4_4;
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_NOT_ITERATED;
9277 dgst_pos0 = 0;
9278 dgst_pos1 = 1;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 3;
9281 break;
9282
9283 case 7600: hash_type = HASH_TYPE_SHA1;
9284 salt_type = SALT_TYPE_INTERN;
9285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_BE
9287 | OPTS_TYPE_PT_ADD80
9288 | OPTS_TYPE_PT_ADDBITS15;
9289 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9290 dgst_size = DGST_SIZE_4_5;
9291 parse_func = redmine_parse_hash;
9292 sort_by_digest = sort_by_digest_4_5;
9293 opti_type = OPTI_TYPE_ZERO_BYTE
9294 | OPTI_TYPE_PRECOMPUTE_INIT
9295 | OPTI_TYPE_EARLY_SKIP
9296 | OPTI_TYPE_NOT_ITERATED
9297 | OPTI_TYPE_PREPENDED_SALT;
9298 dgst_pos0 = 3;
9299 dgst_pos1 = 4;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 1;
9302 break;
9303
9304 case 7700: hash_type = HASH_TYPE_SAPB;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE
9308 | OPTS_TYPE_PT_UPPER
9309 | OPTS_TYPE_ST_UPPER;
9310 kern_type = KERN_TYPE_SAPB;
9311 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9312 parse_func = sapb_parse_hash;
9313 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9314 opti_type = OPTI_TYPE_ZERO_BYTE
9315 | OPTI_TYPE_PRECOMPUTE_INIT
9316 | OPTI_TYPE_NOT_ITERATED;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 1;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 3;
9321 break;
9322
9323 case 7800: hash_type = HASH_TYPE_SAPG;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_BE
9327 | OPTS_TYPE_ST_ADD80
9328 | OPTS_TYPE_ST_UPPER;
9329 kern_type = KERN_TYPE_SAPG;
9330 dgst_size = DGST_SIZE_4_5;
9331 parse_func = sapg_parse_hash;
9332 sort_by_digest = sort_by_digest_4_5;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_PRECOMPUTE_INIT
9335 | OPTI_TYPE_NOT_ITERATED;
9336 dgst_pos0 = 3;
9337 dgst_pos1 = 4;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 1;
9340 break;
9341
9342 case 7900: hash_type = HASH_TYPE_SHA512;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9346 kern_type = KERN_TYPE_DRUPAL7;
9347 dgst_size = DGST_SIZE_8_8;
9348 parse_func = drupal7_parse_hash;
9349 sort_by_digest = sort_by_digest_8_8;
9350 opti_type = OPTI_TYPE_ZERO_BYTE
9351 | OPTI_TYPE_USES_BITS_64;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 8000: hash_type = HASH_TYPE_SHA256;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_BE
9362 | OPTS_TYPE_PT_UNICODE
9363 | OPTS_TYPE_ST_ADD80
9364 | OPTS_TYPE_ST_HEX;
9365 kern_type = KERN_TYPE_SYBASEASE;
9366 dgst_size = DGST_SIZE_4_8;
9367 parse_func = sybasease_parse_hash;
9368 sort_by_digest = sort_by_digest_4_8;
9369 opti_type = OPTI_TYPE_ZERO_BYTE
9370 | OPTI_TYPE_PRECOMPUTE_INIT
9371 | OPTI_TYPE_EARLY_SKIP
9372 | OPTI_TYPE_NOT_ITERATED
9373 | OPTI_TYPE_RAW_HASH;
9374 dgst_pos0 = 3;
9375 dgst_pos1 = 7;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 6;
9378 break;
9379
9380 case 8100: hash_type = HASH_TYPE_SHA1;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9384 kern_type = KERN_TYPE_NETSCALER;
9385 dgst_size = DGST_SIZE_4_5;
9386 parse_func = netscaler_parse_hash;
9387 sort_by_digest = sort_by_digest_4_5;
9388 opti_type = OPTI_TYPE_ZERO_BYTE
9389 | OPTI_TYPE_PRECOMPUTE_INIT
9390 | OPTI_TYPE_PRECOMPUTE_MERKLE
9391 | OPTI_TYPE_EARLY_SKIP
9392 | OPTI_TYPE_NOT_ITERATED
9393 | OPTI_TYPE_PREPENDED_SALT
9394 | OPTI_TYPE_RAW_HASH;
9395 dgst_pos0 = 3;
9396 dgst_pos1 = 4;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 1;
9399 break;
9400
9401 case 8200: hash_type = HASH_TYPE_SHA256;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9405 kern_type = KERN_TYPE_CLOUDKEY;
9406 dgst_size = DGST_SIZE_4_8;
9407 parse_func = cloudkey_parse_hash;
9408 sort_by_digest = sort_by_digest_4_8;
9409 opti_type = OPTI_TYPE_ZERO_BYTE;
9410 dgst_pos0 = 0;
9411 dgst_pos1 = 1;
9412 dgst_pos2 = 2;
9413 dgst_pos3 = 3;
9414 break;
9415
9416 case 8300: hash_type = HASH_TYPE_SHA1;
9417 salt_type = SALT_TYPE_EMBEDDED;
9418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9419 opts_type = OPTS_TYPE_PT_GENERATE_BE
9420 | OPTS_TYPE_ST_HEX
9421 | OPTS_TYPE_ST_ADD80;
9422 kern_type = KERN_TYPE_NSEC3;
9423 dgst_size = DGST_SIZE_4_5;
9424 parse_func = nsec3_parse_hash;
9425 sort_by_digest = sort_by_digest_4_5;
9426 opti_type = OPTI_TYPE_ZERO_BYTE;
9427 dgst_pos0 = 3;
9428 dgst_pos1 = 4;
9429 dgst_pos2 = 2;
9430 dgst_pos3 = 1;
9431 break;
9432
9433 case 8400: hash_type = HASH_TYPE_SHA1;
9434 salt_type = SALT_TYPE_INTERN;
9435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9436 opts_type = OPTS_TYPE_PT_GENERATE_BE
9437 | OPTS_TYPE_PT_ADD80
9438 | OPTS_TYPE_PT_ADDBITS15;
9439 kern_type = KERN_TYPE_WBB3;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = wbb3_parse_hash;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE
9444 | OPTI_TYPE_PRECOMPUTE_INIT
9445 | OPTI_TYPE_NOT_ITERATED;
9446 dgst_pos0 = 3;
9447 dgst_pos1 = 4;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 1;
9450 break;
9451
9452 case 8500: hash_type = HASH_TYPE_DESRACF;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE
9456 | OPTS_TYPE_ST_UPPER;
9457 kern_type = KERN_TYPE_RACF;
9458 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9459 parse_func = racf_parse_hash;
9460 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9461 opti_type = OPTI_TYPE_ZERO_BYTE
9462 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 8600: hash_type = HASH_TYPE_LOTUS5;
9470 salt_type = SALT_TYPE_NONE;
9471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9473 kern_type = KERN_TYPE_LOTUS5;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = lotus5_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
9477 opti_type = OPTI_TYPE_EARLY_SKIP
9478 | OPTI_TYPE_NOT_ITERATED
9479 | OPTI_TYPE_NOT_SALTED
9480 | OPTI_TYPE_RAW_HASH;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 8700: hash_type = HASH_TYPE_LOTUS6;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9491 kern_type = KERN_TYPE_LOTUS6;
9492 dgst_size = DGST_SIZE_4_4;
9493 parse_func = lotus6_parse_hash;
9494 sort_by_digest = sort_by_digest_4_4;
9495 opti_type = OPTI_TYPE_EARLY_SKIP
9496 | OPTI_TYPE_NOT_ITERATED
9497 | OPTI_TYPE_RAW_HASH;
9498 dgst_pos0 = 0;
9499 dgst_pos1 = 1;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 3;
9502 break;
9503
9504 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9508 kern_type = KERN_TYPE_ANDROIDFDE;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = androidfde_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE;
9513 dgst_pos0 = 0;
9514 dgst_pos1 = 1;
9515 dgst_pos2 = 2;
9516 dgst_pos3 = 3;
9517 break;
9518
9519 case 8900: hash_type = HASH_TYPE_SCRYPT;
9520 salt_type = SALT_TYPE_EMBEDDED;
9521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9522 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9523 kern_type = KERN_TYPE_SCRYPT;
9524 dgst_size = DGST_SIZE_4_8;
9525 parse_func = scrypt_parse_hash;
9526 sort_by_digest = sort_by_digest_4_8;
9527 opti_type = OPTI_TYPE_ZERO_BYTE;
9528 dgst_pos0 = 0;
9529 dgst_pos1 = 1;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 3;
9532 break;
9533
9534 case 9000: hash_type = HASH_TYPE_SHA1;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE
9538 | OPTS_TYPE_ST_GENERATE_LE;
9539 kern_type = KERN_TYPE_PSAFE2;
9540 dgst_size = DGST_SIZE_4_5;
9541 parse_func = psafe2_parse_hash;
9542 sort_by_digest = sort_by_digest_4_5;
9543 opti_type = OPTI_TYPE_ZERO_BYTE;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 9100: hash_type = HASH_TYPE_LOTUS8;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9554 kern_type = KERN_TYPE_LOTUS8;
9555 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9556 parse_func = lotus8_parse_hash;
9557 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9558 opti_type = OPTI_TYPE_ZERO_BYTE;
9559 dgst_pos0 = 0;
9560 dgst_pos1 = 1;
9561 dgst_pos2 = 2;
9562 dgst_pos3 = 3;
9563 break;
9564
9565 case 9200: hash_type = HASH_TYPE_SHA256;
9566 salt_type = SALT_TYPE_EMBEDDED;
9567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9568 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9569 kern_type = KERN_TYPE_PBKDF2_SHA256;
9570 dgst_size = DGST_SIZE_4_32;
9571 parse_func = cisco8_parse_hash;
9572 sort_by_digest = sort_by_digest_4_32;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_SLOW_HASH_SIMD;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 1;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 3;
9579 break;
9580
9581 case 9300: hash_type = HASH_TYPE_SCRYPT;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9585 kern_type = KERN_TYPE_SCRYPT;
9586 dgst_size = DGST_SIZE_4_8;
9587 parse_func = cisco9_parse_hash;
9588 sort_by_digest = sort_by_digest_4_8;
9589 opti_type = OPTI_TYPE_ZERO_BYTE;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9600 kern_type = KERN_TYPE_OFFICE2007;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = office2007_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4;
9604 opti_type = OPTI_TYPE_ZERO_BYTE;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9615 kern_type = KERN_TYPE_OFFICE2010;
9616 dgst_size = DGST_SIZE_4_4;
9617 parse_func = office2010_parse_hash;
9618 sort_by_digest = sort_by_digest_4_4;
9619 opti_type = OPTI_TYPE_ZERO_BYTE;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_OFFICE2013;
9631 dgst_size = DGST_SIZE_4_4;
9632 parse_func = office2013_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE
9645 | OPTS_TYPE_PT_ADD80
9646 | OPTS_TYPE_PT_UNICODE;
9647 kern_type = KERN_TYPE_OLDOFFICE01;
9648 dgst_size = DGST_SIZE_4_4;
9649 parse_func = oldoffice01_parse_hash;
9650 sort_by_digest = sort_by_digest_4_4;
9651 opti_type = OPTI_TYPE_ZERO_BYTE
9652 | OPTI_TYPE_PRECOMPUTE_INIT
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE
9664 | OPTS_TYPE_PT_ADD80;
9665 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9666 dgst_size = DGST_SIZE_4_4;
9667 parse_func = oldoffice01cm1_parse_hash;
9668 sort_by_digest = sort_by_digest_4_4;
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_PRECOMPUTE_INIT
9671 | OPTI_TYPE_NOT_ITERATED;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE
9682 | OPTS_TYPE_PT_ADD80
9683 | OPTS_TYPE_PT_UNICODE
9684 | OPTS_TYPE_PT_NEVERCRACK;
9685 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9686 dgst_size = DGST_SIZE_4_4;
9687 parse_func = oldoffice01cm2_parse_hash;
9688 sort_by_digest = sort_by_digest_4_4;
9689 opti_type = OPTI_TYPE_ZERO_BYTE
9690 | OPTI_TYPE_PRECOMPUTE_INIT
9691 | OPTI_TYPE_NOT_ITERATED;
9692 dgst_pos0 = 0;
9693 dgst_pos1 = 1;
9694 dgst_pos2 = 2;
9695 dgst_pos3 = 3;
9696 break;
9697
9698 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9699 salt_type = SALT_TYPE_EMBEDDED;
9700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9701 opts_type = OPTS_TYPE_PT_GENERATE_BE
9702 | OPTS_TYPE_PT_ADD80
9703 | OPTS_TYPE_PT_UNICODE;
9704 kern_type = KERN_TYPE_OLDOFFICE34;
9705 dgst_size = DGST_SIZE_4_4;
9706 parse_func = oldoffice34_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4;
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_PRECOMPUTE_INIT
9710 | OPTI_TYPE_NOT_ITERATED;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9722 dgst_size = DGST_SIZE_4_4;
9723 parse_func = oldoffice34cm1_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4;
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_PRECOMPUTE_INIT
9727 | OPTI_TYPE_NOT_ITERATED;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_BE
9738 | OPTS_TYPE_PT_ADD80
9739 | OPTS_TYPE_PT_UNICODE
9740 | OPTS_TYPE_PT_NEVERCRACK;
9741 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = oldoffice34cm2_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_PRECOMPUTE_INIT
9747 | OPTI_TYPE_NOT_ITERATED;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 9900: hash_type = HASH_TYPE_MD5;
9755 salt_type = SALT_TYPE_NONE;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_RADMIN2;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = radmin2_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_PRECOMPUTE_INIT
9764 | OPTI_TYPE_EARLY_SKIP
9765 | OPTI_TYPE_NOT_ITERATED
9766 | OPTI_TYPE_NOT_SALTED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 3;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 1;
9771 break;
9772
9773 case 10000: hash_type = HASH_TYPE_SHA256;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9777 kern_type = KERN_TYPE_PBKDF2_SHA256;
9778 dgst_size = DGST_SIZE_4_32;
9779 parse_func = djangopbkdf2_parse_hash;
9780 sort_by_digest = sort_by_digest_4_32;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_SLOW_HASH_SIMD;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 10100: hash_type = HASH_TYPE_SIPHASH;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9793 kern_type = KERN_TYPE_SIPHASH;
9794 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9795 parse_func = siphash_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_NOT_ITERATED
9799 | OPTI_TYPE_RAW_HASH;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 10200: hash_type = HASH_TYPE_MD5;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_LE
9810 | OPTS_TYPE_ST_ADD80
9811 | OPTS_TYPE_ST_ADDBITS14;
9812 kern_type = KERN_TYPE_HMACMD5_PW;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = crammd5_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_NOT_ITERATED;
9818 dgst_pos0 = 0;
9819 dgst_pos1 = 3;
9820 dgst_pos2 = 2;
9821 dgst_pos3 = 1;
9822 break;
9823
9824 case 10300: hash_type = HASH_TYPE_SHA1;
9825 salt_type = SALT_TYPE_EMBEDDED;
9826 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9827 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9828 kern_type = KERN_TYPE_SAPH_SHA1;
9829 dgst_size = DGST_SIZE_4_5;
9830 parse_func = saph_sha1_parse_hash;
9831 sort_by_digest = sort_by_digest_4_5;
9832 opti_type = OPTI_TYPE_ZERO_BYTE;
9833 dgst_pos0 = 0;
9834 dgst_pos1 = 1;
9835 dgst_pos2 = 2;
9836 dgst_pos3 = 3;
9837 break;
9838
9839 case 10400: hash_type = HASH_TYPE_PDFU16;
9840 salt_type = SALT_TYPE_EMBEDDED;
9841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9842 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9843 kern_type = KERN_TYPE_PDF11;
9844 dgst_size = DGST_SIZE_4_4;
9845 parse_func = pdf11_parse_hash;
9846 sort_by_digest = sort_by_digest_4_4;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_NOT_ITERATED;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 10410: hash_type = HASH_TYPE_PDFU16;
9856 salt_type = SALT_TYPE_EMBEDDED;
9857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9859 kern_type = KERN_TYPE_PDF11CM1;
9860 dgst_size = DGST_SIZE_4_4;
9861 parse_func = pdf11cm1_parse_hash;
9862 sort_by_digest = sort_by_digest_4_4;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_NOT_ITERATED;
9865 dgst_pos0 = 0;
9866 dgst_pos1 = 1;
9867 dgst_pos2 = 2;
9868 dgst_pos3 = 3;
9869 break;
9870
9871 case 10420: hash_type = HASH_TYPE_PDFU16;
9872 salt_type = SALT_TYPE_EMBEDDED;
9873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9874 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9875 kern_type = KERN_TYPE_PDF11CM2;
9876 dgst_size = DGST_SIZE_4_4;
9877 parse_func = pdf11cm2_parse_hash;
9878 sort_by_digest = sort_by_digest_4_4;
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_NOT_ITERATED;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 10500: hash_type = HASH_TYPE_PDFU16;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9891 kern_type = KERN_TYPE_PDF14;
9892 dgst_size = DGST_SIZE_4_4;
9893 parse_func = pdf14_parse_hash;
9894 sort_by_digest = sort_by_digest_4_4;
9895 opti_type = OPTI_TYPE_ZERO_BYTE
9896 | OPTI_TYPE_NOT_ITERATED;
9897 dgst_pos0 = 0;
9898 dgst_pos1 = 1;
9899 dgst_pos2 = 2;
9900 dgst_pos3 = 3;
9901 break;
9902
9903 case 10600: hash_type = HASH_TYPE_SHA256;
9904 salt_type = SALT_TYPE_EMBEDDED;
9905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9906 opts_type = OPTS_TYPE_PT_GENERATE_BE
9907 | OPTS_TYPE_ST_ADD80
9908 | OPTS_TYPE_ST_ADDBITS15
9909 | OPTS_TYPE_HASH_COPY;
9910 kern_type = KERN_TYPE_SHA256_PWSLT;
9911 dgst_size = DGST_SIZE_4_8;
9912 parse_func = pdf17l3_parse_hash;
9913 sort_by_digest = sort_by_digest_4_8;
9914 opti_type = OPTI_TYPE_ZERO_BYTE
9915 | OPTI_TYPE_PRECOMPUTE_INIT
9916 | OPTI_TYPE_PRECOMPUTE_MERKLE
9917 | OPTI_TYPE_EARLY_SKIP
9918 | OPTI_TYPE_NOT_ITERATED
9919 | OPTI_TYPE_APPENDED_SALT
9920 | OPTI_TYPE_RAW_HASH;
9921 dgst_pos0 = 3;
9922 dgst_pos1 = 7;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 6;
9925 break;
9926
9927 case 10700: hash_type = HASH_TYPE_PDFU32;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_HASH_COPY;
9932 kern_type = KERN_TYPE_PDF17L8;
9933 dgst_size = DGST_SIZE_4_8;
9934 parse_func = pdf17l8_parse_hash;
9935 sort_by_digest = sort_by_digest_4_8;
9936 opti_type = OPTI_TYPE_ZERO_BYTE
9937 | OPTI_TYPE_NOT_ITERATED;
9938 dgst_pos0 = 0;
9939 dgst_pos1 = 1;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 3;
9942 break;
9943
9944 case 10800: hash_type = HASH_TYPE_SHA384;
9945 salt_type = SALT_TYPE_NONE;
9946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_BE
9948 | OPTS_TYPE_PT_ADD80
9949 | OPTS_TYPE_PT_ADDBITS15;
9950 kern_type = KERN_TYPE_SHA384;
9951 dgst_size = DGST_SIZE_8_8;
9952 parse_func = sha384_parse_hash;
9953 sort_by_digest = sort_by_digest_8_8;
9954 opti_type = OPTI_TYPE_ZERO_BYTE
9955 | OPTI_TYPE_PRECOMPUTE_INIT
9956 | OPTI_TYPE_PRECOMPUTE_MERKLE
9957 | OPTI_TYPE_EARLY_SKIP
9958 | OPTI_TYPE_NOT_ITERATED
9959 | OPTI_TYPE_NOT_SALTED
9960 | OPTI_TYPE_USES_BITS_64
9961 | OPTI_TYPE_RAW_HASH;
9962 dgst_pos0 = 6;
9963 dgst_pos1 = 7;
9964 dgst_pos2 = 4;
9965 dgst_pos3 = 5;
9966 break;
9967
9968 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9969 salt_type = SALT_TYPE_EMBEDDED;
9970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9971 opts_type = OPTS_TYPE_PT_GENERATE_LE
9972 | OPTS_TYPE_ST_BASE64
9973 | OPTS_TYPE_HASH_COPY;
9974 kern_type = KERN_TYPE_PBKDF2_SHA256;
9975 dgst_size = DGST_SIZE_4_32;
9976 parse_func = pbkdf2_sha256_parse_hash;
9977 sort_by_digest = sort_by_digest_4_32;
9978 opti_type = OPTI_TYPE_ZERO_BYTE
9979 | OPTI_TYPE_SLOW_HASH_SIMD;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 11000: hash_type = HASH_TYPE_MD5;
9987 salt_type = SALT_TYPE_INTERN;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_PT_ADD80;
9991 kern_type = KERN_TYPE_PRESTASHOP;
9992 dgst_size = DGST_SIZE_4_4;
9993 parse_func = prestashop_parse_hash;
9994 sort_by_digest = sort_by_digest_4_4;
9995 opti_type = OPTI_TYPE_ZERO_BYTE
9996 | OPTI_TYPE_PRECOMPUTE_INIT
9997 | OPTI_TYPE_NOT_ITERATED
9998 | OPTI_TYPE_PREPENDED_SALT;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 3;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 1;
10003 break;
10004
10005 case 11100: hash_type = HASH_TYPE_MD5;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_ST_ADD80;
10010 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10011 dgst_size = DGST_SIZE_4_4;
10012 parse_func = postgresql_auth_parse_hash;
10013 sort_by_digest = sort_by_digest_4_4;
10014 opti_type = OPTI_TYPE_ZERO_BYTE
10015 | OPTI_TYPE_PRECOMPUTE_INIT
10016 | OPTI_TYPE_PRECOMPUTE_MERKLE
10017 | OPTI_TYPE_EARLY_SKIP;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 3;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 1;
10022 break;
10023
10024 case 11200: hash_type = HASH_TYPE_SHA1;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_BE
10028 | OPTS_TYPE_PT_ADD80
10029 | OPTS_TYPE_ST_HEX;
10030 kern_type = KERN_TYPE_MYSQL_AUTH;
10031 dgst_size = DGST_SIZE_4_5;
10032 parse_func = mysql_auth_parse_hash;
10033 sort_by_digest = sort_by_digest_4_5;
10034 opti_type = OPTI_TYPE_ZERO_BYTE
10035 | OPTI_TYPE_EARLY_SKIP;
10036 dgst_pos0 = 3;
10037 dgst_pos1 = 4;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 1;
10040 break;
10041
10042 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_ST_HEX
10047 | OPTS_TYPE_ST_ADD80;
10048 kern_type = KERN_TYPE_BITCOIN_WALLET;
10049 dgst_size = DGST_SIZE_4_4;
10050 parse_func = bitcoin_wallet_parse_hash;
10051 sort_by_digest = sort_by_digest_4_4;
10052 opti_type = OPTI_TYPE_ZERO_BYTE;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 11400: hash_type = HASH_TYPE_MD5;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_PT_ADD80
10064 | OPTS_TYPE_HASH_COPY;
10065 kern_type = KERN_TYPE_SIP_AUTH;
10066 dgst_size = DGST_SIZE_4_4;
10067 parse_func = sip_auth_parse_hash;
10068 sort_by_digest = sort_by_digest_4_4;
10069 opti_type = OPTI_TYPE_ZERO_BYTE;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 3;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 1;
10074 break;
10075
10076 case 11500: hash_type = HASH_TYPE_CRC32;
10077 salt_type = SALT_TYPE_INTERN;
10078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_ST_GENERATE_LE
10081 | OPTS_TYPE_ST_HEX;
10082 kern_type = KERN_TYPE_CRC32;
10083 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10084 parse_func = crc32_parse_hash;
10085 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10086 opti_type = OPTI_TYPE_ZERO_BYTE;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 1;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 3;
10091 break;
10092
10093 case 11600: hash_type = HASH_TYPE_AES;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE
10097 | OPTS_TYPE_PT_NEVERCRACK;
10098 kern_type = KERN_TYPE_SEVEN_ZIP;
10099 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10100 parse_func = seven_zip_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10102 opti_type = OPTI_TYPE_ZERO_BYTE;
10103 dgst_pos0 = 0;
10104 dgst_pos1 = 1;
10105 dgst_pos2 = 2;
10106 dgst_pos3 = 3;
10107 break;
10108
10109 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10110 salt_type = SALT_TYPE_NONE;
10111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10112 opts_type = OPTS_TYPE_PT_GENERATE_LE
10113 | OPTS_TYPE_PT_ADD01;
10114 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10115 dgst_size = DGST_SIZE_4_8;
10116 parse_func = gost2012sbog_256_parse_hash;
10117 sort_by_digest = sort_by_digest_4_8;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10126 salt_type = SALT_TYPE_NONE;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE
10129 | OPTS_TYPE_PT_ADD01;
10130 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10131 dgst_size = DGST_SIZE_4_16;
10132 parse_func = gost2012sbog_512_parse_hash;
10133 sort_by_digest = sort_by_digest_4_16;
10134 opti_type = OPTI_TYPE_ZERO_BYTE;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE
10145 | OPTS_TYPE_ST_BASE64
10146 | OPTS_TYPE_HASH_COPY;
10147 kern_type = KERN_TYPE_PBKDF2_MD5;
10148 dgst_size = DGST_SIZE_4_32;
10149 parse_func = pbkdf2_md5_parse_hash;
10150 sort_by_digest = sort_by_digest_4_32;
10151 opti_type = OPTI_TYPE_ZERO_BYTE
10152 | OPTI_TYPE_SLOW_HASH_SIMD;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 1;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 3;
10157 break;
10158
10159 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE
10163 | OPTS_TYPE_ST_BASE64
10164 | OPTS_TYPE_HASH_COPY;
10165 kern_type = KERN_TYPE_PBKDF2_SHA1;
10166 dgst_size = DGST_SIZE_4_32;
10167 parse_func = pbkdf2_sha1_parse_hash;
10168 sort_by_digest = sort_by_digest_4_32;
10169 opti_type = OPTI_TYPE_ZERO_BYTE
10170 | OPTI_TYPE_SLOW_HASH_SIMD;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE
10181 | OPTS_TYPE_ST_BASE64
10182 | OPTS_TYPE_HASH_COPY;
10183 kern_type = KERN_TYPE_PBKDF2_SHA512;
10184 dgst_size = DGST_SIZE_8_16;
10185 parse_func = pbkdf2_sha512_parse_hash;
10186 sort_by_digest = sort_by_digest_8_16;
10187 opti_type = OPTI_TYPE_ZERO_BYTE
10188 | OPTI_TYPE_USES_BITS_64
10189 | OPTI_TYPE_SLOW_HASH_SIMD;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10200 kern_type = KERN_TYPE_ECRYPTFS;
10201 dgst_size = DGST_SIZE_8_8;
10202 parse_func = ecryptfs_parse_hash;
10203 sort_by_digest = sort_by_digest_8_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE
10205 | OPTI_TYPE_USES_BITS_64;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 12300: hash_type = HASH_TYPE_ORACLET;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10216 kern_type = KERN_TYPE_ORACLET;
10217 dgst_size = DGST_SIZE_8_16;
10218 parse_func = oraclet_parse_hash;
10219 sort_by_digest = sort_by_digest_8_16;
10220 opti_type = OPTI_TYPE_ZERO_BYTE
10221 | OPTI_TYPE_USES_BITS_64;
10222 dgst_pos0 = 0;
10223 dgst_pos1 = 1;
10224 dgst_pos2 = 2;
10225 dgst_pos3 = 3;
10226 break;
10227
10228 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10229 salt_type = SALT_TYPE_EMBEDDED;
10230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10232 kern_type = KERN_TYPE_BSDICRYPT;
10233 dgst_size = DGST_SIZE_4_4;
10234 parse_func = bsdicrypt_parse_hash;
10235 sort_by_digest = sort_by_digest_4_4;
10236 opti_type = OPTI_TYPE_ZERO_BYTE
10237 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 1;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 3;
10242 break;
10243
10244 case 12500: hash_type = HASH_TYPE_RAR3HP;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10248 kern_type = KERN_TYPE_RAR3;
10249 dgst_size = DGST_SIZE_4_4;
10250 parse_func = rar3hp_parse_hash;
10251 sort_by_digest = sort_by_digest_4_4;
10252 opti_type = OPTI_TYPE_ZERO_BYTE;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 1;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 3;
10257 break;
10258
10259 case 12600: hash_type = HASH_TYPE_SHA256;
10260 salt_type = SALT_TYPE_INTERN;
10261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_BE
10263 | OPTS_TYPE_PT_ADD80;
10264 kern_type = KERN_TYPE_CF10;
10265 dgst_size = DGST_SIZE_4_8;
10266 parse_func = cf10_parse_hash;
10267 sort_by_digest = sort_by_digest_4_8;
10268 opti_type = OPTI_TYPE_ZERO_BYTE
10269 | OPTI_TYPE_PRECOMPUTE_INIT
10270 | OPTI_TYPE_EARLY_SKIP
10271 | OPTI_TYPE_NOT_ITERATED;
10272 dgst_pos0 = 3;
10273 dgst_pos1 = 7;
10274 dgst_pos2 = 2;
10275 dgst_pos3 = 6;
10276 break;
10277
10278 case 12700: hash_type = HASH_TYPE_AES;
10279 salt_type = SALT_TYPE_EMBEDDED;
10280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE
10282 | OPTS_TYPE_HASH_COPY;
10283 kern_type = KERN_TYPE_MYWALLET;
10284 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10285 parse_func = mywallet_parse_hash;
10286 sort_by_digest = sort_by_digest_4_5;
10287 opti_type = OPTI_TYPE_ZERO_BYTE;
10288 dgst_pos0 = 0;
10289 dgst_pos1 = 1;
10290 dgst_pos2 = 2;
10291 dgst_pos3 = 3;
10292 break;
10293
10294 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10295 salt_type = SALT_TYPE_EMBEDDED;
10296 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10297 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10298 kern_type = KERN_TYPE_MS_DRSR;
10299 dgst_size = DGST_SIZE_4_8;
10300 parse_func = ms_drsr_parse_hash;
10301 sort_by_digest = sort_by_digest_4_8;
10302 opti_type = OPTI_TYPE_ZERO_BYTE;
10303 dgst_pos0 = 0;
10304 dgst_pos1 = 1;
10305 dgst_pos2 = 2;
10306 dgst_pos3 = 3;
10307 break;
10308
10309 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10310 salt_type = SALT_TYPE_EMBEDDED;
10311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10313 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10314 dgst_size = DGST_SIZE_4_8;
10315 parse_func = androidfde_samsung_parse_hash;
10316 sort_by_digest = sort_by_digest_4_8;
10317 opti_type = OPTI_TYPE_ZERO_BYTE;
10318 dgst_pos0 = 0;
10319 dgst_pos1 = 1;
10320 dgst_pos2 = 2;
10321 dgst_pos3 = 3;
10322 break;
10323
10324 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10325 salt_type = SALT_TYPE_EMBEDDED;
10326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10328 kern_type = KERN_TYPE_RAR5;
10329 dgst_size = DGST_SIZE_4_4;
10330 parse_func = rar5_parse_hash;
10331 sort_by_digest = sort_by_digest_4_4;
10332 opti_type = OPTI_TYPE_ZERO_BYTE;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10343 kern_type = KERN_TYPE_KRB5TGS;
10344 dgst_size = DGST_SIZE_4_4;
10345 parse_func = krb5tgs_parse_hash;
10346 sort_by_digest = sort_by_digest_4_4;
10347 opti_type = OPTI_TYPE_ZERO_BYTE
10348 | OPTI_TYPE_NOT_ITERATED;
10349 dgst_pos0 = 0;
10350 dgst_pos1 = 1;
10351 dgst_pos2 = 2;
10352 dgst_pos3 = 3;
10353 break;
10354
10355 case 13200: hash_type = HASH_TYPE_AES;
10356 salt_type = SALT_TYPE_EMBEDDED;
10357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10359 kern_type = KERN_TYPE_AXCRYPT;
10360 dgst_size = DGST_SIZE_4_4;
10361 parse_func = axcrypt_parse_hash;
10362 sort_by_digest = sort_by_digest_4_4;
10363 opti_type = OPTI_TYPE_ZERO_BYTE;
10364 dgst_pos0 = 0;
10365 dgst_pos1 = 1;
10366 dgst_pos2 = 2;
10367 dgst_pos3 = 3;
10368 break;
10369
10370 case 13300: hash_type = HASH_TYPE_SHA1;
10371 salt_type = SALT_TYPE_NONE;
10372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10373 opts_type = OPTS_TYPE_PT_GENERATE_BE
10374 | OPTS_TYPE_PT_ADD80
10375 | OPTS_TYPE_PT_ADDBITS15;
10376 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10377 dgst_size = DGST_SIZE_4_5;
10378 parse_func = sha1axcrypt_parse_hash;
10379 sort_by_digest = sort_by_digest_4_5;
10380 opti_type = OPTI_TYPE_ZERO_BYTE
10381 | OPTI_TYPE_PRECOMPUTE_INIT
10382 | OPTI_TYPE_EARLY_SKIP
10383 | OPTI_TYPE_NOT_ITERATED
10384 | OPTI_TYPE_NOT_SALTED;
10385 dgst_pos0 = 0;
10386 dgst_pos1 = 4;
10387 dgst_pos2 = 3;
10388 dgst_pos3 = 2;
10389 break;
10390
10391 case 13400: hash_type = HASH_TYPE_AES;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10395 kern_type = KERN_TYPE_KEEPASS;
10396 dgst_size = DGST_SIZE_4_4;
10397 parse_func = keepass_parse_hash;
10398 sort_by_digest = sort_by_digest_4_4;
10399 opti_type = OPTI_TYPE_ZERO_BYTE;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 13500: hash_type = HASH_TYPE_SHA1;
10407 salt_type = SALT_TYPE_EMBEDDED;
10408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_BE
10410 | OPTS_TYPE_PT_UNICODE
10411 | OPTS_TYPE_PT_ADD80;
10412 kern_type = KERN_TYPE_PSTOKEN;
10413 dgst_size = DGST_SIZE_4_5;
10414 parse_func = pstoken_parse_hash;
10415 sort_by_digest = sort_by_digest_4_5;
10416 opti_type = OPTI_TYPE_ZERO_BYTE
10417 | OPTI_TYPE_PRECOMPUTE_INIT
10418 | OPTI_TYPE_EARLY_SKIP
10419 | OPTI_TYPE_NOT_ITERATED
10420 | OPTI_TYPE_PREPENDED_SALT
10421 | OPTI_TYPE_RAW_HASH;
10422 dgst_pos0 = 3;
10423 dgst_pos1 = 4;
10424 dgst_pos2 = 2;
10425 dgst_pos3 = 1;
10426 break;
10427
10428 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10429 salt_type = SALT_TYPE_EMBEDDED;
10430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10432 kern_type = KERN_TYPE_ZIP2;
10433 dgst_size = DGST_SIZE_4_4;
10434 parse_func = zip2_parse_hash;
10435 sort_by_digest = sort_by_digest_4_4;
10436 opti_type = OPTI_TYPE_ZERO_BYTE;
10437 dgst_pos0 = 0;
10438 dgst_pos1 = 1;
10439 dgst_pos2 = 2;
10440 dgst_pos3 = 3;
10441 break;
10442
10443 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10444 salt_type = SALT_TYPE_EMBEDDED;
10445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10447 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10448 dgst_size = DGST_SIZE_4_5;
10449 parse_func = veracrypt_parse_hash_655331;
10450 sort_by_digest = sort_by_digest_4_5;
10451 opti_type = OPTI_TYPE_ZERO_BYTE;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10462 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10463 dgst_size = DGST_SIZE_4_5;
10464 parse_func = veracrypt_parse_hash_655331;
10465 sort_by_digest = sort_by_digest_4_5;
10466 opti_type = OPTI_TYPE_ZERO_BYTE;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10474 salt_type = SALT_TYPE_EMBEDDED;
10475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10477 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10478 dgst_size = DGST_SIZE_4_5;
10479 parse_func = veracrypt_parse_hash_655331;
10480 sort_by_digest = sort_by_digest_4_5;
10481 opti_type = OPTI_TYPE_ZERO_BYTE;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 1;
10484 dgst_pos2 = 2;
10485 dgst_pos3 = 3;
10486 break;
10487
10488 case 13721: hash_type = HASH_TYPE_SHA512;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10492 kern_type = KERN_TYPE_TCSHA512_XTS512;
10493 dgst_size = DGST_SIZE_8_8;
10494 parse_func = veracrypt_parse_hash_500000;
10495 sort_by_digest = sort_by_digest_8_8;
10496 opti_type = OPTI_TYPE_ZERO_BYTE
10497 | OPTI_TYPE_USES_BITS_64;
10498 dgst_pos0 = 0;
10499 dgst_pos1 = 1;
10500 dgst_pos2 = 2;
10501 dgst_pos3 = 3;
10502 break;
10503
10504 case 13722: hash_type = HASH_TYPE_SHA512;
10505 salt_type = SALT_TYPE_EMBEDDED;
10506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10507 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10508 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10509 dgst_size = DGST_SIZE_8_8;
10510 parse_func = veracrypt_parse_hash_500000;
10511 sort_by_digest = sort_by_digest_8_8;
10512 opti_type = OPTI_TYPE_ZERO_BYTE
10513 | OPTI_TYPE_USES_BITS_64;
10514 dgst_pos0 = 0;
10515 dgst_pos1 = 1;
10516 dgst_pos2 = 2;
10517 dgst_pos3 = 3;
10518 break;
10519
10520 case 13723: hash_type = HASH_TYPE_SHA512;
10521 salt_type = SALT_TYPE_EMBEDDED;
10522 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10523 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10524 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10525 dgst_size = DGST_SIZE_8_8;
10526 parse_func = veracrypt_parse_hash_500000;
10527 sort_by_digest = sort_by_digest_8_8;
10528 opti_type = OPTI_TYPE_ZERO_BYTE
10529 | OPTI_TYPE_USES_BITS_64;
10530 dgst_pos0 = 0;
10531 dgst_pos1 = 1;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 3;
10534 break;
10535
10536 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10540 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10541 dgst_size = DGST_SIZE_4_8;
10542 parse_func = veracrypt_parse_hash_500000;
10543 sort_by_digest = sort_by_digest_4_8;
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10555 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10556 dgst_size = DGST_SIZE_4_8;
10557 parse_func = veracrypt_parse_hash_500000;
10558 sort_by_digest = sort_by_digest_4_8;
10559 opti_type = OPTI_TYPE_ZERO_BYTE;
10560 dgst_pos0 = 0;
10561 dgst_pos1 = 1;
10562 dgst_pos2 = 2;
10563 dgst_pos3 = 3;
10564 break;
10565
10566 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10567 salt_type = SALT_TYPE_EMBEDDED;
10568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10570 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10571 dgst_size = DGST_SIZE_4_8;
10572 parse_func = veracrypt_parse_hash_500000;
10573 sort_by_digest = sort_by_digest_4_8;
10574 opti_type = OPTI_TYPE_ZERO_BYTE;
10575 dgst_pos0 = 0;
10576 dgst_pos1 = 1;
10577 dgst_pos2 = 2;
10578 dgst_pos3 = 3;
10579 break;
10580
10581 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10582 salt_type = SALT_TYPE_EMBEDDED;
10583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10585 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10586 dgst_size = DGST_SIZE_4_5;
10587 parse_func = veracrypt_parse_hash_327661;
10588 sort_by_digest = sort_by_digest_4_5;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10597 salt_type = SALT_TYPE_EMBEDDED;
10598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10600 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10601 dgst_size = DGST_SIZE_4_5;
10602 parse_func = veracrypt_parse_hash_327661;
10603 sort_by_digest = sort_by_digest_4_5;
10604 opti_type = OPTI_TYPE_ZERO_BYTE;
10605 dgst_pos0 = 0;
10606 dgst_pos1 = 1;
10607 dgst_pos2 = 2;
10608 dgst_pos3 = 3;
10609 break;
10610
10611 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10612 salt_type = SALT_TYPE_EMBEDDED;
10613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10614 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10615 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10616 dgst_size = DGST_SIZE_4_5;
10617 parse_func = veracrypt_parse_hash_327661;
10618 sort_by_digest = sort_by_digest_4_5;
10619 opti_type = OPTI_TYPE_ZERO_BYTE;
10620 dgst_pos0 = 0;
10621 dgst_pos1 = 1;
10622 dgst_pos2 = 2;
10623 dgst_pos3 = 3;
10624 break;
10625
10626 case 13751: hash_type = HASH_TYPE_SHA256;
10627 salt_type = SALT_TYPE_EMBEDDED;
10628 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10629 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10630 kern_type = KERN_TYPE_VCSHA256_XTS512;
10631 dgst_size = DGST_SIZE_4_8;
10632 parse_func = veracrypt_parse_hash_500000;
10633 sort_by_digest = sort_by_digest_4_8;
10634 opti_type = OPTI_TYPE_ZERO_BYTE;
10635 dgst_pos0 = 0;
10636 dgst_pos1 = 1;
10637 dgst_pos2 = 2;
10638 dgst_pos3 = 3;
10639 break;
10640
10641 case 13752: hash_type = HASH_TYPE_SHA256;
10642 salt_type = SALT_TYPE_EMBEDDED;
10643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10644 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10645 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10646 dgst_size = DGST_SIZE_4_8;
10647 parse_func = veracrypt_parse_hash_500000;
10648 sort_by_digest = sort_by_digest_4_8;
10649 opti_type = OPTI_TYPE_ZERO_BYTE;
10650 dgst_pos0 = 0;
10651 dgst_pos1 = 1;
10652 dgst_pos2 = 2;
10653 dgst_pos3 = 3;
10654 break;
10655
10656 case 13753: hash_type = HASH_TYPE_SHA256;
10657 salt_type = SALT_TYPE_EMBEDDED;
10658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10659 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10660 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10661 dgst_size = DGST_SIZE_4_8;
10662 parse_func = veracrypt_parse_hash_500000;
10663 sort_by_digest = sort_by_digest_4_8;
10664 opti_type = OPTI_TYPE_ZERO_BYTE;
10665 dgst_pos0 = 0;
10666 dgst_pos1 = 1;
10667 dgst_pos2 = 2;
10668 dgst_pos3 = 3;
10669 break;
10670
10671 case 13761: hash_type = HASH_TYPE_SHA256;
10672 salt_type = SALT_TYPE_EMBEDDED;
10673 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10674 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10675 kern_type = KERN_TYPE_VCSHA256_XTS512;
10676 dgst_size = DGST_SIZE_4_8;
10677 parse_func = veracrypt_parse_hash_200000;
10678 sort_by_digest = sort_by_digest_4_8;
10679 opti_type = OPTI_TYPE_ZERO_BYTE;
10680 dgst_pos0 = 0;
10681 dgst_pos1 = 1;
10682 dgst_pos2 = 2;
10683 dgst_pos3 = 3;
10684 break;
10685
10686 case 13762: hash_type = HASH_TYPE_SHA256;
10687 salt_type = SALT_TYPE_EMBEDDED;
10688 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10689 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10690 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10691 dgst_size = DGST_SIZE_4_8;
10692 parse_func = veracrypt_parse_hash_200000;
10693 sort_by_digest = sort_by_digest_4_8;
10694 opti_type = OPTI_TYPE_ZERO_BYTE;
10695 dgst_pos0 = 0;
10696 dgst_pos1 = 1;
10697 dgst_pos2 = 2;
10698 dgst_pos3 = 3;
10699 break;
10700
10701 case 13763: hash_type = HASH_TYPE_SHA256;
10702 salt_type = SALT_TYPE_EMBEDDED;
10703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10704 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10705 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10706 dgst_size = DGST_SIZE_4_8;
10707 parse_func = veracrypt_parse_hash_200000;
10708 sort_by_digest = sort_by_digest_4_8;
10709 opti_type = OPTI_TYPE_ZERO_BYTE;
10710 dgst_pos0 = 0;
10711 dgst_pos1 = 1;
10712 dgst_pos2 = 2;
10713 dgst_pos3 = 3;
10714 break;
10715
10716
10717 default: usage_mini_print (PROGNAME); return (-1);
10718 }
10719
10720 /**
10721 * parser
10722 */
10723
10724 data.parse_func = parse_func;
10725
10726 /**
10727 * misc stuff
10728 */
10729
10730 if (hex_salt)
10731 {
10732 if (salt_type == SALT_TYPE_INTERN)
10733 {
10734 opts_type |= OPTS_TYPE_ST_HEX;
10735 }
10736 else
10737 {
10738 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10739
10740 return (-1);
10741 }
10742 }
10743
10744 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10745 | (salt_type == SALT_TYPE_EXTERN)
10746 | (salt_type == SALT_TYPE_EMBEDDED)
10747 | (salt_type == SALT_TYPE_VIRTUAL));
10748
10749 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10750
10751 data.hash_type = hash_type;
10752 data.attack_mode = attack_mode;
10753 data.attack_kern = attack_kern;
10754 data.attack_exec = attack_exec;
10755 data.kern_type = kern_type;
10756 data.opts_type = opts_type;
10757 data.dgst_size = dgst_size;
10758 data.salt_type = salt_type;
10759 data.isSalted = isSalted;
10760 data.sort_by_digest = sort_by_digest;
10761 data.dgst_pos0 = dgst_pos0;
10762 data.dgst_pos1 = dgst_pos1;
10763 data.dgst_pos2 = dgst_pos2;
10764 data.dgst_pos3 = dgst_pos3;
10765
10766 esalt_size = 0;
10767
10768 switch (hash_mode)
10769 {
10770 case 2500: esalt_size = sizeof (wpa_t); break;
10771 case 5300: esalt_size = sizeof (ikepsk_t); break;
10772 case 5400: esalt_size = sizeof (ikepsk_t); break;
10773 case 5500: esalt_size = sizeof (netntlm_t); break;
10774 case 5600: esalt_size = sizeof (netntlm_t); break;
10775 case 6211: esalt_size = sizeof (tc_t); break;
10776 case 6212: esalt_size = sizeof (tc_t); break;
10777 case 6213: esalt_size = sizeof (tc_t); break;
10778 case 6221: esalt_size = sizeof (tc_t); break;
10779 case 6222: esalt_size = sizeof (tc_t); break;
10780 case 6223: esalt_size = sizeof (tc_t); break;
10781 case 6231: esalt_size = sizeof (tc_t); break;
10782 case 6232: esalt_size = sizeof (tc_t); break;
10783 case 6233: esalt_size = sizeof (tc_t); break;
10784 case 6241: esalt_size = sizeof (tc_t); break;
10785 case 6242: esalt_size = sizeof (tc_t); break;
10786 case 6243: esalt_size = sizeof (tc_t); break;
10787 case 6600: esalt_size = sizeof (agilekey_t); break;
10788 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10789 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10790 case 7300: esalt_size = sizeof (rakp_t); break;
10791 case 7500: esalt_size = sizeof (krb5pa_t); break;
10792 case 8200: esalt_size = sizeof (cloudkey_t); break;
10793 case 8800: esalt_size = sizeof (androidfde_t); break;
10794 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10795 case 9400: esalt_size = sizeof (office2007_t); break;
10796 case 9500: esalt_size = sizeof (office2010_t); break;
10797 case 9600: esalt_size = sizeof (office2013_t); break;
10798 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10799 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10800 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10801 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10802 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10803 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10804 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10805 case 10200: esalt_size = sizeof (cram_md5_t); break;
10806 case 10400: esalt_size = sizeof (pdf_t); break;
10807 case 10410: esalt_size = sizeof (pdf_t); break;
10808 case 10420: esalt_size = sizeof (pdf_t); break;
10809 case 10500: esalt_size = sizeof (pdf_t); break;
10810 case 10600: esalt_size = sizeof (pdf_t); break;
10811 case 10700: esalt_size = sizeof (pdf_t); break;
10812 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10813 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10814 case 11400: esalt_size = sizeof (sip_t); break;
10815 case 11600: esalt_size = sizeof (seven_zip_t); break;
10816 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10817 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10818 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10819 case 13000: esalt_size = sizeof (rar5_t); break;
10820 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10821 case 13400: esalt_size = sizeof (keepass_t); break;
10822 case 13500: esalt_size = sizeof (pstoken_t); break;
10823 case 13600: esalt_size = sizeof (zip2_t); break;
10824 case 13711: esalt_size = sizeof (tc_t); break;
10825 case 13712: esalt_size = sizeof (tc_t); break;
10826 case 13713: esalt_size = sizeof (tc_t); break;
10827 case 13721: esalt_size = sizeof (tc_t); break;
10828 case 13722: esalt_size = sizeof (tc_t); break;
10829 case 13723: esalt_size = sizeof (tc_t); break;
10830 case 13731: esalt_size = sizeof (tc_t); break;
10831 case 13732: esalt_size = sizeof (tc_t); break;
10832 case 13733: esalt_size = sizeof (tc_t); break;
10833 case 13741: esalt_size = sizeof (tc_t); break;
10834 case 13742: esalt_size = sizeof (tc_t); break;
10835 case 13743: esalt_size = sizeof (tc_t); break;
10836 case 13751: esalt_size = sizeof (tc_t); break;
10837 case 13752: esalt_size = sizeof (tc_t); break;
10838 case 13753: esalt_size = sizeof (tc_t); break;
10839 case 13761: esalt_size = sizeof (tc_t); break;
10840 case 13762: esalt_size = sizeof (tc_t); break;
10841 case 13763: esalt_size = sizeof (tc_t); break;
10842 }
10843
10844 data.esalt_size = esalt_size;
10845
10846 /**
10847 * choose dictionary parser
10848 */
10849
10850 if (hash_type == HASH_TYPE_LM)
10851 {
10852 get_next_word_func = get_next_word_lm;
10853 }
10854 else if (opts_type & OPTS_TYPE_PT_UPPER)
10855 {
10856 get_next_word_func = get_next_word_uc;
10857 }
10858 else
10859 {
10860 get_next_word_func = get_next_word_std;
10861 }
10862
10863 /**
10864 * dictstat
10865 */
10866
10867 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10868
10869 #ifdef _POSIX
10870 size_t dictstat_nmemb = 0;
10871 #endif
10872
10873 #ifdef _WIN
10874 uint dictstat_nmemb = 0;
10875 #endif
10876
10877 char dictstat[256] = { 0 };
10878
10879 FILE *dictstat_fp = NULL;
10880
10881 if (keyspace == 0)
10882 {
10883 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10884
10885 dictstat_fp = fopen (dictstat, "rb");
10886
10887 if (dictstat_fp)
10888 {
10889 #ifdef _POSIX
10890 struct stat tmpstat;
10891
10892 fstat (fileno (dictstat_fp), &tmpstat);
10893 #endif
10894
10895 #ifdef _WIN
10896 struct stat64 tmpstat;
10897
10898 _fstat64 (fileno (dictstat_fp), &tmpstat);
10899 #endif
10900
10901 if (tmpstat.st_mtime < COMPTIME)
10902 {
10903 /* with v0.15 the format changed so we have to ensure user is using a good version
10904 since there is no version-header in the dictstat file */
10905
10906 fclose (dictstat_fp);
10907
10908 unlink (dictstat);
10909 }
10910 else
10911 {
10912 while (!feof (dictstat_fp))
10913 {
10914 dictstat_t d;
10915
10916 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10917
10918 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10919
10920 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10921 {
10922 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10923
10924 return -1;
10925 }
10926 }
10927
10928 fclose (dictstat_fp);
10929 }
10930 }
10931 }
10932
10933 /**
10934 * potfile
10935 */
10936
10937 char potfile[256] = { 0 };
10938
10939 if (potfile_path == NULL)
10940 {
10941 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10942 }
10943 else
10944 {
10945 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10946 }
10947
10948 data.pot_fp = NULL;
10949
10950 FILE *out_fp = NULL;
10951 FILE *pot_fp = NULL;
10952
10953 if (show == 1 || left == 1)
10954 {
10955 pot_fp = fopen (potfile, "rb");
10956
10957 if (pot_fp == NULL)
10958 {
10959 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10960
10961 return (-1);
10962 }
10963
10964 if (outfile != NULL)
10965 {
10966 if ((out_fp = fopen (outfile, "ab")) == NULL)
10967 {
10968 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10969
10970 fclose (pot_fp);
10971
10972 return (-1);
10973 }
10974 }
10975 else
10976 {
10977 out_fp = stdout;
10978 }
10979 }
10980 else
10981 {
10982 if (potfile_disable == 0)
10983 {
10984 pot_fp = fopen (potfile, "ab");
10985
10986 if (pot_fp == NULL)
10987 {
10988 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10989
10990 return (-1);
10991 }
10992
10993 data.pot_fp = pot_fp;
10994 }
10995 }
10996
10997 pot_t *pot = NULL;
10998
10999 uint pot_cnt = 0;
11000 uint pot_avail = 0;
11001
11002 if (show == 1 || left == 1)
11003 {
11004 SUPPRESS_OUTPUT = 1;
11005
11006 pot_avail = count_lines (pot_fp);
11007
11008 rewind (pot_fp);
11009
11010 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11011
11012 uint pot_hashes_avail = 0;
11013
11014 uint line_num = 0;
11015
11016 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11017
11018 while (!feof (pot_fp))
11019 {
11020 line_num++;
11021
11022 int line_len = fgetl (pot_fp, line_buf);
11023
11024 if (line_len == 0) continue;
11025
11026 char *plain_buf = line_buf + line_len;
11027
11028 pot_t *pot_ptr = &pot[pot_cnt];
11029
11030 hash_t *hashes_buf = &pot_ptr->hash;
11031
11032 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11033 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11034
11035 if (pot_cnt == pot_hashes_avail)
11036 {
11037 uint pos = 0;
11038
11039 for (pos = 0; pos < INCR_POT; pos++)
11040 {
11041 if ((pot_cnt + pos) >= pot_avail) break;
11042
11043 pot_t *tmp_pot = &pot[pot_cnt + pos];
11044
11045 hash_t *tmp_hash = &tmp_pot->hash;
11046
11047 tmp_hash->digest = mymalloc (dgst_size);
11048
11049 if (isSalted)
11050 {
11051 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11052 }
11053
11054 if (esalt_size)
11055 {
11056 tmp_hash->esalt = mymalloc (esalt_size);
11057 }
11058
11059 pot_hashes_avail++;
11060 }
11061 }
11062
11063 int plain_len = 0;
11064
11065 int parser_status;
11066
11067 int iter = MAX_CUT_TRIES;
11068
11069 do
11070 {
11071 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11072 {
11073 if (line_buf[i] == ':')
11074 {
11075 line_len--;
11076
11077 break;
11078 }
11079 }
11080
11081 if (data.hash_mode != 2500)
11082 {
11083 parser_status = parse_func (line_buf, line_len, hashes_buf);
11084 }
11085 else
11086 {
11087 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11088
11089 if (line_len > max_salt_size)
11090 {
11091 parser_status = PARSER_GLOBAL_LENGTH;
11092 }
11093 else
11094 {
11095 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11096
11097 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11098
11099 hashes_buf->salt->salt_len = line_len;
11100
11101 parser_status = PARSER_OK;
11102 }
11103 }
11104
11105 // if NOT parsed without error, we add the ":" to the plain
11106
11107 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11108 {
11109 plain_len++;
11110 plain_buf--;
11111 }
11112
11113 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11114
11115 if (parser_status < PARSER_GLOBAL_ZERO)
11116 {
11117 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11118
11119 continue;
11120 }
11121
11122 if (plain_len >= 255) continue;
11123
11124 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11125
11126 pot_ptr->plain_len = plain_len;
11127
11128 pot_cnt++;
11129 }
11130
11131 myfree (line_buf);
11132
11133 fclose (pot_fp);
11134
11135 SUPPRESS_OUTPUT = 0;
11136
11137 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11138 }
11139
11140 /**
11141 * word len
11142 */
11143
11144 uint pw_min = PW_MIN;
11145 uint pw_max = PW_MAX;
11146
11147 switch (hash_mode)
11148 {
11149 case 125: if (pw_max > 32) pw_max = 32;
11150 break;
11151 case 400: if (pw_max > 40) pw_max = 40;
11152 break;
11153 case 500: if (pw_max > 16) pw_max = 16;
11154 break;
11155 case 1500: if (pw_max > 8) pw_max = 8;
11156 break;
11157 case 1600: if (pw_max > 16) pw_max = 16;
11158 break;
11159 case 1800: if (pw_max > 16) pw_max = 16;
11160 break;
11161 case 2100: if (pw_max > 16) pw_max = 16;
11162 break;
11163 case 2500: if (pw_min < 8) pw_min = 8;
11164 break;
11165 case 3000: if (pw_max > 7) pw_max = 7;
11166 break;
11167 case 5200: if (pw_max > 24) pw_max = 24;
11168 break;
11169 case 5800: if (pw_max > 16) pw_max = 16;
11170 break;
11171 case 6300: if (pw_max > 16) pw_max = 16;
11172 break;
11173 case 7400: if (pw_max > 16) pw_max = 16;
11174 break;
11175 case 7500: if (pw_max > 8) pw_max = 8;
11176 break;
11177 case 7900: if (pw_max > 48) pw_max = 48;
11178 break;
11179 case 8500: if (pw_max > 8) pw_max = 8;
11180 break;
11181 case 8600: if (pw_max > 16) pw_max = 16;
11182 break;
11183 case 9710: pw_min = 5;
11184 pw_max = 5;
11185 break;
11186 case 9810: pw_min = 5;
11187 pw_max = 5;
11188 break;
11189 case 10410: pw_min = 5;
11190 pw_max = 5;
11191 break;
11192 case 10300: if (pw_max < 3) pw_min = 3;
11193 if (pw_max > 40) pw_max = 40;
11194 break;
11195 case 10500: if (pw_max < 3) pw_min = 3;
11196 if (pw_max > 40) pw_max = 40;
11197 break;
11198 case 10700: if (pw_max > 16) pw_max = 16;
11199 break;
11200 case 11300: if (pw_max > 40) pw_max = 40;
11201 break;
11202 case 11600: if (pw_max > 32) pw_max = 32;
11203 break;
11204 case 12500: if (pw_max > 20) pw_max = 20;
11205 break;
11206 case 12800: if (pw_max > 24) pw_max = 24;
11207 break;
11208 }
11209
11210 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11211 {
11212 switch (attack_kern)
11213 {
11214 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11215 break;
11216 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11217 break;
11218 }
11219 }
11220
11221 /**
11222 * charsets : keep them together for more easy maintainnce
11223 */
11224
11225 cs_t mp_sys[6] = { { { 0 }, 0 } };
11226 cs_t mp_usr[4] = { { { 0 }, 0 } };
11227
11228 mp_setup_sys (mp_sys);
11229
11230 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11231 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11232 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11233 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11234
11235 /**
11236 * load hashes, part I: find input mode, count hashes
11237 */
11238
11239 uint hashlist_mode = 0;
11240 uint hashlist_format = HLFMT_HASHCAT;
11241
11242 uint hashes_avail = 0;
11243
11244 if (benchmark == 0)
11245 {
11246 struct stat f;
11247
11248 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11249
11250 if ((hash_mode == 2500) ||
11251 (hash_mode == 5200) ||
11252 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11253 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11254 (hash_mode == 9000))
11255 {
11256 hashlist_mode = HL_MODE_ARG;
11257
11258 char *hashfile = myargv[optind];
11259
11260 data.hashfile = hashfile;
11261
11262 logfile_top_var_string ("target", hashfile);
11263 }
11264
11265 if (hashlist_mode == HL_MODE_ARG)
11266 {
11267 if (hash_mode == 2500)
11268 {
11269 struct stat st;
11270
11271 if (stat (data.hashfile, &st) == -1)
11272 {
11273 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11274
11275 return (-1);
11276 }
11277
11278 hashes_avail = st.st_size / sizeof (hccap_t);
11279 }
11280 else
11281 {
11282 hashes_avail = 1;
11283 }
11284 }
11285 else if (hashlist_mode == HL_MODE_FILE)
11286 {
11287 char *hashfile = myargv[optind];
11288
11289 data.hashfile = hashfile;
11290
11291 logfile_top_var_string ("target", hashfile);
11292
11293 FILE *fp = NULL;
11294
11295 if ((fp = fopen (hashfile, "rb")) == NULL)
11296 {
11297 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11298
11299 return (-1);
11300 }
11301
11302 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11303
11304 hashes_avail = count_lines (fp);
11305
11306 rewind (fp);
11307
11308 if (hashes_avail == 0)
11309 {
11310 log_error ("ERROR: hashfile is empty or corrupt");
11311
11312 fclose (fp);
11313
11314 return (-1);
11315 }
11316
11317 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11318
11319 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11320 {
11321 log_error ("ERROR: remove not supported in native hashfile-format mode");
11322
11323 fclose (fp);
11324
11325 return (-1);
11326 }
11327
11328 fclose (fp);
11329 }
11330 }
11331 else
11332 {
11333 hashlist_mode = HL_MODE_ARG;
11334
11335 hashes_avail = 1;
11336 }
11337
11338 if (hash_mode == 3000) hashes_avail *= 2;
11339
11340 data.hashlist_mode = hashlist_mode;
11341 data.hashlist_format = hashlist_format;
11342
11343 logfile_top_uint (hashlist_mode);
11344 logfile_top_uint (hashlist_format);
11345
11346 /**
11347 * load hashes, part II: allocate required memory, set pointers
11348 */
11349
11350 hash_t *hashes_buf = NULL;
11351 void *digests_buf = NULL;
11352 salt_t *salts_buf = NULL;
11353 void *esalts_buf = NULL;
11354
11355 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11356
11357 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11358
11359 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11360 {
11361 u32 hash_pos;
11362
11363 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11364 {
11365 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11366
11367 hashes_buf[hash_pos].hash_info = hash_info;
11368
11369 if (username && (remove || show || left))
11370 {
11371 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11372 }
11373
11374 if (benchmark)
11375 {
11376 hash_info->orighash = (char *) mymalloc (256);
11377 }
11378 }
11379 }
11380
11381 if (isSalted)
11382 {
11383 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11384
11385 if (esalt_size)
11386 {
11387 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11388 }
11389 }
11390 else
11391 {
11392 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11393 }
11394
11395 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11396 {
11397 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11398
11399 if (isSalted)
11400 {
11401 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11402
11403 if (esalt_size)
11404 {
11405 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11406 }
11407 }
11408 else
11409 {
11410 hashes_buf[hash_pos].salt = &salts_buf[0];
11411 }
11412 }
11413
11414 /**
11415 * load hashes, part III: parse hashes or generate them if benchmark
11416 */
11417
11418 uint hashes_cnt = 0;
11419
11420 if (benchmark == 0)
11421 {
11422 if (keyspace == 1)
11423 {
11424 // useless to read hash file for keyspace, cheat a little bit w/ optind
11425 }
11426 else if (hashes_avail == 0)
11427 {
11428 }
11429 else if (hashlist_mode == HL_MODE_ARG)
11430 {
11431 char *input_buf = myargv[optind];
11432
11433 uint input_len = strlen (input_buf);
11434
11435 logfile_top_var_string ("target", input_buf);
11436
11437 char *hash_buf = NULL;
11438 int hash_len = 0;
11439
11440 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11441
11442 bool hash_fmt_error = 0;
11443
11444 if (hash_len < 1) hash_fmt_error = 1;
11445 if (hash_buf == NULL) hash_fmt_error = 1;
11446
11447 if (hash_fmt_error)
11448 {
11449 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11450 }
11451 else
11452 {
11453 if (opts_type & OPTS_TYPE_HASH_COPY)
11454 {
11455 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11456
11457 hash_info_tmp->orighash = mystrdup (hash_buf);
11458 }
11459
11460 if (isSalted)
11461 {
11462 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11463 }
11464
11465 int parser_status = PARSER_OK;
11466
11467 if (hash_mode == 2500)
11468 {
11469 if (hash_len == 0)
11470 {
11471 log_error ("ERROR: hccap file not specified");
11472
11473 return (-1);
11474 }
11475
11476 hashlist_mode = HL_MODE_FILE;
11477
11478 data.hashlist_mode = hashlist_mode;
11479
11480 FILE *fp = fopen (hash_buf, "rb");
11481
11482 if (fp == NULL)
11483 {
11484 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11485
11486 return (-1);
11487 }
11488
11489 if (hashes_avail < 1)
11490 {
11491 log_error ("ERROR: hccap file is empty or corrupt");
11492
11493 fclose (fp);
11494
11495 return (-1);
11496 }
11497
11498 uint hccap_size = sizeof (hccap_t);
11499
11500 char *in = (char *) mymalloc (hccap_size);
11501
11502 while (!feof (fp))
11503 {
11504 int n = fread (in, hccap_size, 1, fp);
11505
11506 if (n != 1)
11507 {
11508 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11509
11510 break;
11511 }
11512
11513 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11514
11515 if (parser_status != PARSER_OK)
11516 {
11517 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11518
11519 continue;
11520 }
11521
11522 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11523
11524 if ((show == 1) || (left == 1))
11525 {
11526 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11527
11528 char *salt_ptr = (char *) tmp_salt->salt_buf;
11529
11530 int cur_pos = tmp_salt->salt_len;
11531 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11532
11533 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11534
11535 // do the appending task
11536
11537 snprintf (salt_ptr + cur_pos,
11538 rem_len,
11539 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11540 wpa->orig_mac1[0],
11541 wpa->orig_mac1[1],
11542 wpa->orig_mac1[2],
11543 wpa->orig_mac1[3],
11544 wpa->orig_mac1[4],
11545 wpa->orig_mac1[5],
11546 wpa->orig_mac2[0],
11547 wpa->orig_mac2[1],
11548 wpa->orig_mac2[2],
11549 wpa->orig_mac2[3],
11550 wpa->orig_mac2[4],
11551 wpa->orig_mac2[5]);
11552
11553 // memset () the remaining part of the salt
11554
11555 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11556 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11557
11558 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11559
11560 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11561 }
11562
11563 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);
11564 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);
11565
11566 hashes_cnt++;
11567 }
11568
11569 fclose (fp);
11570
11571 myfree (in);
11572 }
11573 else if (hash_mode == 3000)
11574 {
11575 if (hash_len == 32)
11576 {
11577 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11578
11579 hash_t *lm_hash_left = NULL;
11580
11581 if (parser_status == PARSER_OK)
11582 {
11583 lm_hash_left = &hashes_buf[hashes_cnt];
11584
11585 hashes_cnt++;
11586 }
11587 else
11588 {
11589 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11590 }
11591
11592 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11593
11594 hash_t *lm_hash_right = NULL;
11595
11596 if (parser_status == PARSER_OK)
11597 {
11598 lm_hash_right = &hashes_buf[hashes_cnt];
11599
11600 hashes_cnt++;
11601 }
11602 else
11603 {
11604 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11605 }
11606
11607 // show / left
11608
11609 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11610 {
11611 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);
11612 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);
11613 }
11614 }
11615 else
11616 {
11617 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11618
11619 if (parser_status == PARSER_OK)
11620 {
11621 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11622 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11623 }
11624
11625 if (parser_status == PARSER_OK)
11626 {
11627 hashes_cnt++;
11628 }
11629 else
11630 {
11631 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11632 }
11633 }
11634 }
11635 else
11636 {
11637 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11638
11639 if (parser_status == PARSER_OK)
11640 {
11641 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11642 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11643 }
11644
11645 if (parser_status == PARSER_OK)
11646 {
11647 hashes_cnt++;
11648 }
11649 else
11650 {
11651 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11652 }
11653 }
11654 }
11655 }
11656 else if (hashlist_mode == HL_MODE_FILE)
11657 {
11658 char *hashfile = data.hashfile;
11659
11660 FILE *fp;
11661
11662 if ((fp = fopen (hashfile, "rb")) == NULL)
11663 {
11664 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11665
11666 return (-1);
11667 }
11668
11669 uint line_num = 0;
11670
11671 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11672
11673 while (!feof (fp))
11674 {
11675 line_num++;
11676
11677 int line_len = fgetl (fp, line_buf);
11678
11679 if (line_len == 0) continue;
11680
11681 char *hash_buf = NULL;
11682 int hash_len = 0;
11683
11684 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11685
11686 bool hash_fmt_error = 0;
11687
11688 if (hash_len < 1) hash_fmt_error = 1;
11689 if (hash_buf == NULL) hash_fmt_error = 1;
11690
11691 if (hash_fmt_error)
11692 {
11693 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11694
11695 continue;
11696 }
11697
11698 if (username)
11699 {
11700 char *user_buf = NULL;
11701 int user_len = 0;
11702
11703 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11704
11705 if (remove || show)
11706 {
11707 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11708
11709 *user = (user_t *) mymalloc (sizeof (user_t));
11710
11711 user_t *user_ptr = *user;
11712
11713 if (user_buf != NULL)
11714 {
11715 user_ptr->user_name = mystrdup (user_buf);
11716 }
11717 else
11718 {
11719 user_ptr->user_name = mystrdup ("");
11720 }
11721
11722 user_ptr->user_len = user_len;
11723 }
11724 }
11725
11726 if (opts_type & OPTS_TYPE_HASH_COPY)
11727 {
11728 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11729
11730 hash_info_tmp->orighash = mystrdup (hash_buf);
11731 }
11732
11733 if (isSalted)
11734 {
11735 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11736 }
11737
11738 if (hash_mode == 3000)
11739 {
11740 if (hash_len == 32)
11741 {
11742 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11743
11744 if (parser_status < PARSER_GLOBAL_ZERO)
11745 {
11746 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11747
11748 continue;
11749 }
11750
11751 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11752
11753 hashes_cnt++;
11754
11755 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11756
11757 if (parser_status < PARSER_GLOBAL_ZERO)
11758 {
11759 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11760
11761 continue;
11762 }
11763
11764 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11765
11766 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);
11767
11768 hashes_cnt++;
11769
11770 // show / left
11771
11772 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);
11773 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);
11774 }
11775 else
11776 {
11777 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11778
11779 if (parser_status < PARSER_GLOBAL_ZERO)
11780 {
11781 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11782
11783 continue;
11784 }
11785
11786 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);
11787
11788 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11789 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11790
11791 hashes_cnt++;
11792 }
11793 }
11794 else
11795 {
11796 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11797
11798 if (parser_status < PARSER_GLOBAL_ZERO)
11799 {
11800 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11801
11802 continue;
11803 }
11804
11805 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);
11806
11807 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11808 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11809
11810 hashes_cnt++;
11811 }
11812 }
11813
11814 myfree (line_buf);
11815
11816 fclose (fp);
11817
11818 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11819
11820 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11821 }
11822 }
11823 else
11824 {
11825 if (isSalted)
11826 {
11827 hashes_buf[0].salt->salt_len = 8;
11828
11829 // special salt handling
11830
11831 switch (hash_mode)
11832 {
11833 case 1500: hashes_buf[0].salt->salt_len = 2;
11834 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11835 break;
11836 case 1731: hashes_buf[0].salt->salt_len = 4;
11837 break;
11838 case 2410: hashes_buf[0].salt->salt_len = 4;
11839 break;
11840 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11841 break;
11842 case 3100: hashes_buf[0].salt->salt_len = 1;
11843 break;
11844 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11845 break;
11846 case 5800: hashes_buf[0].salt->salt_len = 16;
11847 break;
11848 case 6800: hashes_buf[0].salt->salt_len = 32;
11849 break;
11850 case 8400: hashes_buf[0].salt->salt_len = 40;
11851 break;
11852 case 8800: hashes_buf[0].salt->salt_len = 16;
11853 break;
11854 case 8900: hashes_buf[0].salt->salt_len = 16;
11855 hashes_buf[0].salt->scrypt_N = 1024;
11856 hashes_buf[0].salt->scrypt_r = 1;
11857 hashes_buf[0].salt->scrypt_p = 1;
11858 break;
11859 case 9100: hashes_buf[0].salt->salt_len = 16;
11860 break;
11861 case 9300: hashes_buf[0].salt->salt_len = 14;
11862 hashes_buf[0].salt->scrypt_N = 16384;
11863 hashes_buf[0].salt->scrypt_r = 1;
11864 hashes_buf[0].salt->scrypt_p = 1;
11865 break;
11866 case 9400: hashes_buf[0].salt->salt_len = 16;
11867 break;
11868 case 9500: hashes_buf[0].salt->salt_len = 16;
11869 break;
11870 case 9600: hashes_buf[0].salt->salt_len = 16;
11871 break;
11872 case 9700: hashes_buf[0].salt->salt_len = 16;
11873 break;
11874 case 9710: hashes_buf[0].salt->salt_len = 16;
11875 break;
11876 case 9720: hashes_buf[0].salt->salt_len = 16;
11877 break;
11878 case 9800: hashes_buf[0].salt->salt_len = 16;
11879 break;
11880 case 9810: hashes_buf[0].salt->salt_len = 16;
11881 break;
11882 case 9820: hashes_buf[0].salt->salt_len = 16;
11883 break;
11884 case 10300: hashes_buf[0].salt->salt_len = 12;
11885 break;
11886 case 11500: hashes_buf[0].salt->salt_len = 4;
11887 break;
11888 case 11600: hashes_buf[0].salt->salt_len = 4;
11889 break;
11890 case 12400: hashes_buf[0].salt->salt_len = 4;
11891 break;
11892 case 12500: hashes_buf[0].salt->salt_len = 8;
11893 break;
11894 case 12600: hashes_buf[0].salt->salt_len = 64;
11895 break;
11896 }
11897
11898 // special esalt handling
11899
11900 switch (hash_mode)
11901 {
11902 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11903 break;
11904 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11905 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11906 break;
11907 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11908 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11909 break;
11910 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11911 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11912 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11913 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11914 break;
11915 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11916 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11917 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11918 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11919 break;
11920 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11921 break;
11922 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11923 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11924 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11925 break;
11926 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11927 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11928 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11929 break;
11930 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11931 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11932 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11933 break;
11934 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11935 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11936 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11937 break;
11938 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11939 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11940 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11941 break;
11942 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11943 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11944 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11945 break;
11946 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11947 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11948 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11949 break;
11950 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11951 break;
11952 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11953 break;
11954 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11955 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11956 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11957 break;
11958 }
11959 }
11960
11961 // set hashfile
11962
11963 switch (hash_mode)
11964 {
11965 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11966 break;
11967 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11968 break;
11969 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11970 break;
11971 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11972 break;
11973 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11974 break;
11975 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11976 break;
11977 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11978 break;
11979 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11980 break;
11981 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11982 break;
11983 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11984 break;
11985 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11986 break;
11987 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11988 break;
11989 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11990 break;
11991 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11992 break;
11993 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11994 break;
11995 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11996 break;
11997 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11998 break;
11999 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12000 break;
12001 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12002 break;
12003 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12004 break;
12005 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12006 break;
12007 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12008 break;
12009 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12010 break;
12011 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12012 break;
12013 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12014 break;
12015 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12016 break;
12017 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12018 break;
12019 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12020 break;
12021 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12022 break;
12023 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12024 break;
12025 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12026 break;
12027 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12028 break;
12029 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12030 break;
12031 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12032 break;
12033 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12034 break;
12035 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12036 break;
12037 }
12038
12039 // set default iterations
12040
12041 switch (hash_mode)
12042 {
12043 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12044 break;
12045 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12046 break;
12047 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12048 break;
12049 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12050 break;
12051 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12052 break;
12053 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12054 break;
12055 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12056 break;
12057 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12058 break;
12059 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12060 break;
12061 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12062 break;
12063 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12064 break;
12065 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12066 break;
12067 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12068 break;
12069 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12070 break;
12071 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12072 break;
12073 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12074 break;
12075 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12076 break;
12077 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12078 break;
12079 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12080 break;
12081 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12082 break;
12083 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12084 break;
12085 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12086 break;
12087 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12088 break;
12089 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12090 break;
12091 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12092 break;
12093 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12094 break;
12095 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12096 break;
12097 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12098 break;
12099 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12100 break;
12101 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12102 break;
12103 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12104 break;
12105 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12106 break;
12107 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12108 break;
12109 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12110 break;
12111 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12112 break;
12113 case 8900: hashes_buf[0].salt->salt_iter = 1;
12114 break;
12115 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12116 break;
12117 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12118 break;
12119 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12120 break;
12121 case 9300: hashes_buf[0].salt->salt_iter = 1;
12122 break;
12123 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12124 break;
12125 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12126 break;
12127 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12128 break;
12129 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12130 break;
12131 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12132 break;
12133 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12134 break;
12135 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12136 break;
12137 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12138 break;
12139 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12140 break;
12141 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12142 break;
12143 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12144 break;
12145 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12146 break;
12147 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12148 break;
12149 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12150 break;
12151 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12152 break;
12153 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12154 break;
12155 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12156 break;
12157 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12158 break;
12159 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12160 break;
12161 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12162 break;
12163 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12164 break;
12165 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12166 break;
12167 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12168 break;
12169 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12170 break;
12171 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12172 break;
12173 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12174 break;
12175 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12176 break;
12177 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12178 break;
12179 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12180 break;
12181 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12182 break;
12183 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12184 break;
12185 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12186 break;
12187 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12188 break;
12189 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12190 break;
12191 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12192 break;
12193 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12194 break;
12195 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12196 break;
12197 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12198 break;
12199 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12200 break;
12201 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12202 break;
12203 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12204 break;
12205 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12206 break;
12207 }
12208
12209 hashes_cnt = 1;
12210 }
12211
12212 if (show == 1 || left == 1)
12213 {
12214 for (uint i = 0; i < pot_cnt; i++)
12215 {
12216 pot_t *pot_ptr = &pot[i];
12217
12218 hash_t *hashes_buf = &pot_ptr->hash;
12219
12220 local_free (hashes_buf->digest);
12221
12222 if (isSalted)
12223 {
12224 local_free (hashes_buf->salt);
12225 }
12226 }
12227
12228 local_free (pot);
12229
12230 if (data.quiet == 0) log_info_nn ("");
12231
12232 return (0);
12233 }
12234
12235 if (keyspace == 0)
12236 {
12237 if (hashes_cnt == 0)
12238 {
12239 log_error ("ERROR: No hashes loaded");
12240
12241 return (-1);
12242 }
12243 }
12244
12245 /**
12246 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12247 */
12248
12249 if (data.outfile != NULL)
12250 {
12251 if (data.hashfile != NULL)
12252 {
12253 #ifdef _POSIX
12254 struct stat tmpstat_outfile;
12255 struct stat tmpstat_hashfile;
12256 #endif
12257
12258 #ifdef _WIN
12259 struct stat64 tmpstat_outfile;
12260 struct stat64 tmpstat_hashfile;
12261 #endif
12262
12263 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12264
12265 if (tmp_outfile_fp)
12266 {
12267 #ifdef _POSIX
12268 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12269 #endif
12270
12271 #ifdef _WIN
12272 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12273 #endif
12274
12275 fclose (tmp_outfile_fp);
12276 }
12277
12278 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12279
12280 if (tmp_hashfile_fp)
12281 {
12282 #ifdef _POSIX
12283 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12284 #endif
12285
12286 #ifdef _WIN
12287 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12288 #endif
12289
12290 fclose (tmp_hashfile_fp);
12291 }
12292
12293 if (tmp_outfile_fp && tmp_outfile_fp)
12294 {
12295 tmpstat_outfile.st_mode = 0;
12296 tmpstat_outfile.st_nlink = 0;
12297 tmpstat_outfile.st_uid = 0;
12298 tmpstat_outfile.st_gid = 0;
12299 tmpstat_outfile.st_rdev = 0;
12300 tmpstat_outfile.st_atime = 0;
12301
12302 tmpstat_hashfile.st_mode = 0;
12303 tmpstat_hashfile.st_nlink = 0;
12304 tmpstat_hashfile.st_uid = 0;
12305 tmpstat_hashfile.st_gid = 0;
12306 tmpstat_hashfile.st_rdev = 0;
12307 tmpstat_hashfile.st_atime = 0;
12308
12309 #ifdef _POSIX
12310 tmpstat_outfile.st_blksize = 0;
12311 tmpstat_outfile.st_blocks = 0;
12312
12313 tmpstat_hashfile.st_blksize = 0;
12314 tmpstat_hashfile.st_blocks = 0;
12315 #endif
12316
12317 #ifdef _POSIX
12318 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12319 {
12320 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12321
12322 return (-1);
12323 }
12324 #endif
12325
12326 #ifdef _WIN
12327 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12328 {
12329 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12330
12331 return (-1);
12332 }
12333 #endif
12334 }
12335 }
12336 }
12337
12338 /**
12339 * Remove duplicates
12340 */
12341
12342 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12343
12344 if (isSalted)
12345 {
12346 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12347 }
12348 else
12349 {
12350 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12351 }
12352
12353 uint hashes_cnt_orig = hashes_cnt;
12354
12355 hashes_cnt = 1;
12356
12357 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12358 {
12359 if (isSalted)
12360 {
12361 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12362 {
12363 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12364 }
12365 }
12366 else
12367 {
12368 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12369 }
12370
12371 if (hashes_pos > hashes_cnt)
12372 {
12373 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12374 }
12375
12376 hashes_cnt++;
12377 }
12378
12379 /**
12380 * Potfile removes
12381 */
12382
12383 uint potfile_remove_cracks = 0;
12384
12385 if (potfile_disable == 0)
12386 {
12387 hash_t hash_buf;
12388
12389 hash_buf.digest = mymalloc (dgst_size);
12390 hash_buf.salt = NULL;
12391 hash_buf.esalt = NULL;
12392 hash_buf.hash_info = NULL;
12393 hash_buf.cracked = 0;
12394
12395 if (isSalted)
12396 {
12397 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12398 }
12399
12400 if (esalt_size)
12401 {
12402 hash_buf.esalt = mymalloc (esalt_size);
12403 }
12404
12405 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12406
12407 // no solution for these special hash types (for instane because they use hashfile in output etc)
12408 if ((hash_mode != 5200) &&
12409 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12410 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12411 (hash_mode != 9000))
12412 {
12413 FILE *fp = fopen (potfile, "rb");
12414
12415 if (fp != NULL)
12416 {
12417 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12418
12419 // to be safe work with a copy (because of line_len loop, i etc)
12420 // moved up here because it's easier to handle continue case
12421 // it's just 64kb
12422
12423 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12424
12425 while (!feof (fp))
12426 {
12427 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12428
12429 if (ptr == NULL) break;
12430
12431 int line_len = strlen (line_buf);
12432
12433 if (line_len == 0) continue;
12434
12435 int iter = MAX_CUT_TRIES;
12436
12437 for (int i = line_len - 1; i && iter; i--, line_len--)
12438 {
12439 if (line_buf[i] != ':') continue;
12440
12441 if (isSalted)
12442 {
12443 memset (hash_buf.salt, 0, sizeof (salt_t));
12444 }
12445
12446 hash_t *found = NULL;
12447
12448 if (hash_mode == 6800)
12449 {
12450 if (i < 64) // 64 = 16 * uint in salt_buf[]
12451 {
12452 // manipulate salt_buf
12453 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12454
12455 hash_buf.salt->salt_len = i;
12456
12457 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12458 }
12459 }
12460 else if (hash_mode == 2500)
12461 {
12462 if (i < 64) // 64 = 16 * uint in salt_buf[]
12463 {
12464 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12465 // manipulate salt_buf
12466
12467 memcpy (line_buf_cpy, line_buf, i);
12468
12469 char *mac2_pos = strrchr (line_buf_cpy, ':');
12470
12471 if (mac2_pos == NULL) continue;
12472
12473 mac2_pos[0] = 0;
12474 mac2_pos++;
12475
12476 if (strlen (mac2_pos) != 12) continue;
12477
12478 char *mac1_pos = strrchr (line_buf_cpy, ':');
12479
12480 if (mac1_pos == NULL) continue;
12481
12482 mac1_pos[0] = 0;
12483 mac1_pos++;
12484
12485 if (strlen (mac1_pos) != 12) continue;
12486
12487 uint essid_length = mac1_pos - line_buf_cpy - 1;
12488
12489 // here we need the ESSID
12490 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12491
12492 hash_buf.salt->salt_len = essid_length;
12493
12494 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12495
12496 if (found)
12497 {
12498 wpa_t *wpa = (wpa_t *) found->esalt;
12499
12500 // compare hex string(s) vs binary MAC address(es)
12501
12502 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12503 {
12504 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12505 {
12506 found = NULL;
12507
12508 break;
12509 }
12510 }
12511
12512 // early skip ;)
12513 if (!found) continue;
12514
12515 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12516 {
12517 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12518 {
12519 found = NULL;
12520
12521 break;
12522 }
12523 }
12524 }
12525 }
12526 }
12527 else
12528 {
12529 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12530
12531 if (parser_status == PARSER_OK)
12532 {
12533 if (isSalted)
12534 {
12535 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12536 }
12537 else
12538 {
12539 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12540 }
12541 }
12542 }
12543
12544 if (found == NULL) continue;
12545
12546 if (!found->cracked) potfile_remove_cracks++;
12547
12548 found->cracked = 1;
12549
12550 if (found) break;
12551
12552 iter--;
12553 }
12554 }
12555
12556 myfree (line_buf_cpy);
12557
12558 myfree (line_buf);
12559
12560 fclose (fp);
12561 }
12562 }
12563
12564 if (esalt_size)
12565 {
12566 local_free (hash_buf.esalt);
12567 }
12568
12569 if (isSalted)
12570 {
12571 local_free (hash_buf.salt);
12572 }
12573
12574 local_free (hash_buf.digest);
12575 }
12576
12577 /**
12578 * Now generate all the buffers required for later
12579 */
12580
12581 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12582
12583 salt_t *salts_buf_new = NULL;
12584 void *esalts_buf_new = NULL;
12585
12586 if (isSalted)
12587 {
12588 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12589
12590 if (esalt_size)
12591 {
12592 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12593 }
12594 }
12595 else
12596 {
12597 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12598 }
12599
12600 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12601
12602 uint digests_cnt = hashes_cnt;
12603 uint digests_done = 0;
12604
12605 size_t size_digests = digests_cnt * dgst_size;
12606 size_t size_shown = digests_cnt * sizeof (uint);
12607
12608 uint *digests_shown = (uint *) mymalloc (size_shown);
12609 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12610
12611 uint salts_cnt = 0;
12612 uint salts_done = 0;
12613
12614 hashinfo_t **hash_info = NULL;
12615
12616 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12617 {
12618 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12619
12620 if (username && (remove || show))
12621 {
12622 uint user_pos;
12623
12624 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12625 {
12626 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12627
12628 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12629 }
12630 }
12631 }
12632
12633 uint *salts_shown = (uint *) mymalloc (size_shown);
12634
12635 salt_t *salt_buf;
12636
12637 {
12638 // copied from inner loop
12639
12640 salt_buf = &salts_buf_new[salts_cnt];
12641
12642 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12643
12644 if (esalt_size)
12645 {
12646 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12647 }
12648
12649 salt_buf->digests_cnt = 0;
12650 salt_buf->digests_done = 0;
12651 salt_buf->digests_offset = 0;
12652
12653 salts_cnt++;
12654 }
12655
12656 if (hashes_buf[0].cracked == 1)
12657 {
12658 digests_shown[0] = 1;
12659
12660 digests_done++;
12661
12662 salt_buf->digests_done++;
12663 }
12664
12665 salt_buf->digests_cnt++;
12666
12667 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12668
12669 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12670 {
12671 hash_info[0] = hashes_buf[0].hash_info;
12672 }
12673
12674 // copy from inner loop
12675
12676 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12677 {
12678 if (isSalted)
12679 {
12680 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12681 {
12682 salt_buf = &salts_buf_new[salts_cnt];
12683
12684 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12685
12686 if (esalt_size)
12687 {
12688 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12689 }
12690
12691 salt_buf->digests_cnt = 0;
12692 salt_buf->digests_done = 0;
12693 salt_buf->digests_offset = hashes_pos;
12694
12695 salts_cnt++;
12696 }
12697 }
12698
12699 if (hashes_buf[hashes_pos].cracked == 1)
12700 {
12701 digests_shown[hashes_pos] = 1;
12702
12703 digests_done++;
12704
12705 salt_buf->digests_done++;
12706 }
12707
12708 salt_buf->digests_cnt++;
12709
12710 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12711
12712 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12713 {
12714 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12715 }
12716 }
12717
12718 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12719 {
12720 salt_t *salt_buf = &salts_buf_new[salt_pos];
12721
12722 if (salt_buf->digests_done == salt_buf->digests_cnt)
12723 {
12724 salts_shown[salt_pos] = 1;
12725
12726 salts_done++;
12727 }
12728
12729 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12730 }
12731
12732 local_free (digests_buf);
12733 local_free (salts_buf);
12734 local_free (esalts_buf);
12735
12736 digests_buf = digests_buf_new;
12737 salts_buf = salts_buf_new;
12738 esalts_buf = esalts_buf_new;
12739
12740 local_free (hashes_buf);
12741
12742 /**
12743 * special modification not set from parser
12744 */
12745
12746 switch (hash_mode)
12747 {
12748 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12749 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12750 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12751 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12752 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12753 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12754 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12755 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12756 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12757 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12758 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12759 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12760 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12761 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12762 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12763 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12764 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12765 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12766 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12767 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12768 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12769 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12770 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12771 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12772 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12773 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12774 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12775 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12776 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12777 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12778 }
12779
12780 if (truecrypt_keyfiles)
12781 {
12782 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12783
12784 char *keyfiles = strdup (truecrypt_keyfiles);
12785
12786 char *keyfile = strtok (keyfiles, ",");
12787
12788 do
12789 {
12790 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12791
12792 } while ((keyfile = strtok (NULL, ",")) != NULL);
12793
12794 free (keyfiles);
12795 }
12796
12797 if (veracrypt_keyfiles)
12798 {
12799 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12800
12801 char *keyfiles = strdup (veracrypt_keyfiles);
12802
12803 char *keyfile = strtok (keyfiles, ",");
12804
12805 do
12806 {
12807 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12808
12809 } while ((keyfile = strtok (NULL, ",")) != NULL);
12810
12811 free (keyfiles);
12812 }
12813
12814 data.digests_cnt = digests_cnt;
12815 data.digests_done = digests_done;
12816 data.digests_buf = digests_buf;
12817 data.digests_shown = digests_shown;
12818 data.digests_shown_tmp = digests_shown_tmp;
12819
12820 data.salts_cnt = salts_cnt;
12821 data.salts_done = salts_done;
12822 data.salts_buf = salts_buf;
12823 data.salts_shown = salts_shown;
12824
12825 data.esalts_buf = esalts_buf;
12826 data.hash_info = hash_info;
12827
12828 /**
12829 * Automatic Optimizers
12830 */
12831
12832 if (salts_cnt == 1)
12833 opti_type |= OPTI_TYPE_SINGLE_SALT;
12834
12835 if (digests_cnt == 1)
12836 opti_type |= OPTI_TYPE_SINGLE_HASH;
12837
12838 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12839 opti_type |= OPTI_TYPE_NOT_ITERATED;
12840
12841 if (attack_mode == ATTACK_MODE_BF)
12842 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12843
12844 data.opti_type = opti_type;
12845
12846 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12847 {
12848 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12849 {
12850 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12851 {
12852 if (opts_type & OPTS_TYPE_ST_ADD80)
12853 {
12854 opts_type &= ~OPTS_TYPE_ST_ADD80;
12855 opts_type |= OPTS_TYPE_PT_ADD80;
12856 }
12857
12858 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12859 {
12860 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12861 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12862 }
12863
12864 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12865 {
12866 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12867 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12868 }
12869 }
12870 }
12871 }
12872
12873 /**
12874 * Some algorithm, like descrypt, can benefit from JIT compilation
12875 */
12876
12877 int force_jit_compilation = -1;
12878
12879 if (hash_mode == 8900)
12880 {
12881 force_jit_compilation = 8900;
12882 }
12883 else if (hash_mode == 9300)
12884 {
12885 force_jit_compilation = 8900;
12886 }
12887 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12888 {
12889 force_jit_compilation = 1500;
12890 }
12891
12892 /**
12893 * generate bitmap tables
12894 */
12895
12896 const uint bitmap_shift1 = 5;
12897 const uint bitmap_shift2 = 13;
12898
12899 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12900
12901 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12902 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12903 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12904 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12905 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12906 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12907 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12908 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12909
12910 uint bitmap_bits;
12911 uint bitmap_nums;
12912 uint bitmap_mask;
12913 uint bitmap_size;
12914
12915 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12916 {
12917 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12918
12919 bitmap_nums = 1 << bitmap_bits;
12920
12921 bitmap_mask = bitmap_nums - 1;
12922
12923 bitmap_size = bitmap_nums * sizeof (uint);
12924
12925 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12926
12927 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;
12928 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;
12929
12930 break;
12931 }
12932
12933 bitmap_nums = 1 << bitmap_bits;
12934
12935 bitmap_mask = bitmap_nums - 1;
12936
12937 bitmap_size = bitmap_nums * sizeof (uint);
12938
12939 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);
12940 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);
12941
12942 /**
12943 * prepare quick rule
12944 */
12945
12946 data.rule_buf_l = rule_buf_l;
12947 data.rule_buf_r = rule_buf_r;
12948
12949 int rule_len_l = (int) strlen (rule_buf_l);
12950 int rule_len_r = (int) strlen (rule_buf_r);
12951
12952 data.rule_len_l = rule_len_l;
12953 data.rule_len_r = rule_len_r;
12954
12955 /**
12956 * load rules
12957 */
12958
12959 uint *all_kernel_rules_cnt = NULL;
12960
12961 kernel_rule_t **all_kernel_rules_buf = NULL;
12962
12963 if (rp_files_cnt)
12964 {
12965 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12966
12967 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12968 }
12969
12970 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12971
12972 int rule_len = 0;
12973
12974 for (uint i = 0; i < rp_files_cnt; i++)
12975 {
12976 uint kernel_rules_avail = 0;
12977
12978 uint kernel_rules_cnt = 0;
12979
12980 kernel_rule_t *kernel_rules_buf = NULL;
12981
12982 char *rp_file = rp_files[i];
12983
12984 char in[BLOCK_SIZE] = { 0 };
12985 char out[BLOCK_SIZE] = { 0 };
12986
12987 FILE *fp = NULL;
12988
12989 uint rule_line = 0;
12990
12991 if ((fp = fopen (rp_file, "rb")) == NULL)
12992 {
12993 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12994
12995 return (-1);
12996 }
12997
12998 while (!feof (fp))
12999 {
13000 memset (rule_buf, 0, HCBUFSIZ);
13001
13002 rule_len = fgetl (fp, rule_buf);
13003
13004 rule_line++;
13005
13006 if (rule_len == 0) continue;
13007
13008 if (rule_buf[0] == '#') continue;
13009
13010 if (kernel_rules_avail == kernel_rules_cnt)
13011 {
13012 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13013
13014 kernel_rules_avail += INCR_RULES;
13015 }
13016
13017 memset (in, 0, BLOCK_SIZE);
13018 memset (out, 0, BLOCK_SIZE);
13019
13020 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13021
13022 if (result == -1)
13023 {
13024 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13025
13026 continue;
13027 }
13028
13029 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13030 {
13031 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13032
13033 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13034
13035 continue;
13036 }
13037
13038 /* its so slow
13039 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13040 {
13041 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13042
13043 continue;
13044 }
13045 */
13046
13047 kernel_rules_cnt++;
13048 }
13049
13050 fclose (fp);
13051
13052 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13053
13054 all_kernel_rules_buf[i] = kernel_rules_buf;
13055 }
13056
13057 /**
13058 * merge rules or automatic rule generator
13059 */
13060
13061 uint kernel_rules_cnt = 0;
13062
13063 kernel_rule_t *kernel_rules_buf = NULL;
13064
13065 if (attack_mode == ATTACK_MODE_STRAIGHT)
13066 {
13067 if (rp_files_cnt)
13068 {
13069 kernel_rules_cnt = 1;
13070
13071 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13072
13073 repeats[0] = kernel_rules_cnt;
13074
13075 for (uint i = 0; i < rp_files_cnt; i++)
13076 {
13077 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13078
13079 repeats[i + 1] = kernel_rules_cnt;
13080 }
13081
13082 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13083
13084 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13085
13086 for (uint i = 0; i < kernel_rules_cnt; i++)
13087 {
13088 uint out_pos = 0;
13089
13090 kernel_rule_t *out = &kernel_rules_buf[i];
13091
13092 for (uint j = 0; j < rp_files_cnt; j++)
13093 {
13094 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13095 uint in_pos;
13096
13097 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13098
13099 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13100 {
13101 if (out_pos == RULES_MAX - 1)
13102 {
13103 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13104
13105 break;
13106 }
13107
13108 out->cmds[out_pos] = in->cmds[in_pos];
13109 }
13110 }
13111 }
13112
13113 local_free (repeats);
13114 }
13115 else if (rp_gen)
13116 {
13117 uint kernel_rules_avail = 0;
13118
13119 while (kernel_rules_cnt < rp_gen)
13120 {
13121 if (kernel_rules_avail == kernel_rules_cnt)
13122 {
13123 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13124
13125 kernel_rules_avail += INCR_RULES;
13126 }
13127
13128 memset (rule_buf, 0, HCBUFSIZ);
13129
13130 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13131
13132 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13133
13134 kernel_rules_cnt++;
13135 }
13136 }
13137 }
13138
13139 myfree (rule_buf);
13140
13141 /**
13142 * generate NOP rules
13143 */
13144
13145 if (kernel_rules_cnt == 0)
13146 {
13147 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13148
13149 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13150
13151 kernel_rules_cnt++;
13152 }
13153
13154 data.kernel_rules_cnt = kernel_rules_cnt;
13155 data.kernel_rules_buf = kernel_rules_buf;
13156
13157 /**
13158 * OpenCL platforms: detect
13159 */
13160
13161 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13162 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13163
13164 cl_uint platforms_cnt = 0;
13165 cl_uint platform_devices_cnt = 0;
13166
13167 if (keyspace == 0)
13168 {
13169 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13170
13171 if (platforms_cnt == 0)
13172 {
13173 log_info ("");
13174 log_info ("ATTENTION! No OpenCL compatible platform found");
13175 log_info ("");
13176 log_info ("You're probably missing the OpenCL runtime installation");
13177 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13178 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13179 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13180 log_info ("");
13181
13182 return (-1);
13183 }
13184
13185 if (opencl_platforms_filter != (uint) -1)
13186 {
13187 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13188
13189 if (opencl_platforms_filter > platform_cnt_mask)
13190 {
13191 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13192
13193 return (-1);
13194 }
13195 }
13196 }
13197
13198 /**
13199 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13200 */
13201
13202 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13203 {
13204 cl_platform_id platform = platforms[platform_id];
13205
13206 char platform_vendor[INFOSZ] = { 0 };
13207
13208 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13209
13210 #ifdef HAVE_HWMON
13211 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13212 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13213 {
13214 // make sure that we do not directly control the fan for NVidia
13215
13216 gpu_temp_retain = 0;
13217
13218 data.gpu_temp_retain = gpu_temp_retain;
13219 }
13220 #endif // HAVE_NVML || HAVE_NVAPI
13221 #endif
13222 }
13223
13224 /**
13225 * OpenCL device types:
13226 * 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.
13227 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13228 */
13229
13230 if (opencl_device_types == NULL)
13231 {
13232 cl_device_type device_types_all = 0;
13233
13234 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13235 {
13236 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13237
13238 cl_platform_id platform = platforms[platform_id];
13239
13240 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13241
13242 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13243 {
13244 cl_device_id device = platform_devices[platform_devices_id];
13245
13246 cl_device_type device_type;
13247
13248 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13249
13250 device_types_all |= device_type;
13251 }
13252 }
13253
13254 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13255 {
13256 device_types_filter |= CL_DEVICE_TYPE_CPU;
13257 }
13258 }
13259
13260 /**
13261 * OpenCL devices: simply push all devices from all platforms into the same device array
13262 */
13263
13264 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13265
13266 data.devices_param = devices_param;
13267
13268 uint devices_cnt = 0;
13269
13270 uint devices_active = 0;
13271
13272 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13273 {
13274 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13275
13276 cl_platform_id platform = platforms[platform_id];
13277
13278 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13279
13280 char platform_vendor[INFOSZ] = { 0 };
13281
13282 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13283
13284 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13285 // this causes trouble with vendor id based macros
13286 // we'll assign generic to those without special optimization available
13287
13288 cl_uint platform_vendor_id = 0;
13289
13290 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13291 {
13292 platform_vendor_id = VENDOR_ID_AMD;
13293 }
13294 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13295 {
13296 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13297 }
13298 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13299 {
13300 platform_vendor_id = VENDOR_ID_APPLE;
13301 }
13302 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13303 {
13304 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13305 }
13306 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13307 {
13308 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13309 }
13310 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13311 {
13312 platform_vendor_id = VENDOR_ID_MESA;
13313 }
13314 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13315 {
13316 platform_vendor_id = VENDOR_ID_NV;
13317 }
13318 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13319 {
13320 platform_vendor_id = VENDOR_ID_POCL;
13321 }
13322 else
13323 {
13324 platform_vendor_id = VENDOR_ID_GENERIC;
13325 }
13326
13327 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13328 {
13329 size_t param_value_size = 0;
13330
13331 const uint device_id = devices_cnt;
13332
13333 hc_device_param_t *device_param = &data.devices_param[device_id];
13334
13335 device_param->platform_vendor_id = platform_vendor_id;
13336
13337 device_param->device = platform_devices[platform_devices_id];
13338
13339 device_param->device_id = device_id;
13340
13341 device_param->platform_devices_id = platform_devices_id;
13342
13343 // device_type
13344
13345 cl_device_type device_type;
13346
13347 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13348
13349 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13350
13351 device_param->device_type = device_type;
13352
13353 // device_name
13354
13355 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13356
13357 char *device_name = (char *) mymalloc (param_value_size);
13358
13359 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13360
13361 device_param->device_name = device_name;
13362
13363 // device_vendor
13364
13365 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13366
13367 char *device_vendor = (char *) mymalloc (param_value_size);
13368
13369 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13370
13371 device_param->device_vendor = device_vendor;
13372
13373 cl_uint device_vendor_id = 0;
13374
13375 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13376 {
13377 device_vendor_id = VENDOR_ID_AMD;
13378 }
13379 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13380 {
13381 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13382 }
13383 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13384 {
13385 device_vendor_id = VENDOR_ID_APPLE;
13386 }
13387 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13388 {
13389 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13390 }
13391 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13392 {
13393 device_vendor_id = VENDOR_ID_INTEL_SDK;
13394 }
13395 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13396 {
13397 device_vendor_id = VENDOR_ID_MESA;
13398 }
13399 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13400 {
13401 device_vendor_id = VENDOR_ID_NV;
13402 }
13403 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13404 {
13405 device_vendor_id = VENDOR_ID_POCL;
13406 }
13407 else
13408 {
13409 device_vendor_id = VENDOR_ID_GENERIC;
13410 }
13411
13412 device_param->device_vendor_id = device_vendor_id;
13413
13414 // tuning db
13415
13416 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13417
13418 // device_version
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13421
13422 char *device_version = (char *) mymalloc (param_value_size);
13423
13424 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13425
13426 device_param->device_version = device_version;
13427
13428 // device_opencl_version
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13431
13432 char *device_opencl_version = (char *) mymalloc (param_value_size);
13433
13434 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13435
13436 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13437
13438 myfree (device_opencl_version);
13439
13440 // vector_width
13441
13442 cl_uint vector_width;
13443
13444 if (opencl_vector_width_chgd == 0)
13445 {
13446 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13447 {
13448 if (opti_type & OPTI_TYPE_USES_BITS_64)
13449 {
13450 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13451 }
13452 else
13453 {
13454 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13455 }
13456 }
13457 else
13458 {
13459 vector_width = (cl_uint) tuningdb_entry->vector_width;
13460 }
13461 }
13462 else
13463 {
13464 vector_width = opencl_vector_width;
13465 }
13466
13467 if (vector_width > 16) vector_width = 16;
13468
13469 device_param->vector_width = vector_width;
13470
13471 // max_compute_units
13472
13473 cl_uint device_processors;
13474
13475 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13476
13477 device_param->device_processors = device_processors;
13478
13479 // device_maxmem_alloc
13480 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13481
13482 cl_ulong device_maxmem_alloc;
13483
13484 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13485
13486 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13487
13488 // device_global_mem
13489
13490 cl_ulong device_global_mem;
13491
13492 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13493
13494 device_param->device_global_mem = device_global_mem;
13495
13496 // max_work_group_size
13497
13498 size_t device_maxworkgroup_size;
13499
13500 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13501
13502 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13503
13504 // max_clock_frequency
13505
13506 cl_uint device_maxclock_frequency;
13507
13508 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13509
13510 device_param->device_maxclock_frequency = device_maxclock_frequency;
13511
13512 // device_endian_little
13513
13514 cl_bool device_endian_little;
13515
13516 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13517
13518 if (device_endian_little == CL_FALSE)
13519 {
13520 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13521
13522 device_param->skipped = 1;
13523 }
13524
13525 // device_available
13526
13527 cl_bool device_available;
13528
13529 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13530
13531 if (device_available == CL_FALSE)
13532 {
13533 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13534
13535 device_param->skipped = 1;
13536 }
13537
13538 // device_compiler_available
13539
13540 cl_bool device_compiler_available;
13541
13542 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13543
13544 if (device_compiler_available == CL_FALSE)
13545 {
13546 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13547
13548 device_param->skipped = 1;
13549 }
13550
13551 // device_execution_capabilities
13552
13553 cl_device_exec_capabilities device_execution_capabilities;
13554
13555 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13556
13557 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13558 {
13559 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13560
13561 device_param->skipped = 1;
13562 }
13563
13564 // device_extensions
13565
13566 size_t device_extensions_size;
13567
13568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13569
13570 char *device_extensions = mymalloc (device_extensions_size + 1);
13571
13572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13573
13574 if (strstr (device_extensions, "base_atomics") == 0)
13575 {
13576 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13577
13578 device_param->skipped = 1;
13579 }
13580
13581 if (strstr (device_extensions, "byte_addressable_store") == 0)
13582 {
13583 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13584
13585 device_param->skipped = 1;
13586 }
13587
13588 myfree (device_extensions);
13589
13590 // device_local_mem_size
13591
13592 cl_ulong device_local_mem_size;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13595
13596 if (device_local_mem_size < 32768)
13597 {
13598 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13599
13600 device_param->skipped = 1;
13601 }
13602
13603 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13604 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13605 // This results in both utilizing it for 50%
13606 // However, Intel has much better SIMD control over their own hardware
13607 // It makes sense to give them full control over their own hardware
13608
13609 if (device_type & CL_DEVICE_TYPE_CPU)
13610 {
13611 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13612 {
13613 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13614
13615 device_param->skipped = 1;
13616 }
13617 }
13618
13619 // skipped
13620
13621 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13622 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13623
13624 // driver_version
13625
13626 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13627
13628 char *driver_version = (char *) mymalloc (param_value_size);
13629
13630 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13631
13632 device_param->driver_version = driver_version;
13633
13634 // device_name_chksum
13635
13636 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13637
13638 #if __x86_64__
13639 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);
13640 #else
13641 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);
13642 #endif
13643
13644 uint device_name_digest[4] = { 0 };
13645
13646 md5_64 ((uint *) device_name_chksum, device_name_digest);
13647
13648 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13649
13650 device_param->device_name_chksum = device_name_chksum;
13651
13652 // device_processor_cores
13653
13654 if (device_type & CL_DEVICE_TYPE_CPU)
13655 {
13656 cl_uint device_processor_cores = 1;
13657
13658 device_param->device_processor_cores = device_processor_cores;
13659 }
13660
13661 if (device_type & CL_DEVICE_TYPE_GPU)
13662 {
13663 if (device_vendor_id == VENDOR_ID_AMD)
13664 {
13665 cl_uint device_processor_cores = 0;
13666
13667 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13668
13669 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13670
13671 device_param->device_processor_cores = device_processor_cores;
13672 }
13673 else if (device_vendor_id == VENDOR_ID_NV)
13674 {
13675 cl_uint kernel_exec_timeout = 0;
13676
13677 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13678
13679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13680
13681 device_param->kernel_exec_timeout = kernel_exec_timeout;
13682
13683 cl_uint device_processor_cores = 0;
13684
13685 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13686
13687 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13688
13689 device_param->device_processor_cores = device_processor_cores;
13690
13691 cl_uint sm_minor = 0;
13692 cl_uint sm_major = 0;
13693
13694 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13695 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13696
13697 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13698 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13699
13700 device_param->sm_minor = sm_minor;
13701 device_param->sm_major = sm_major;
13702 }
13703 else
13704 {
13705 cl_uint device_processor_cores = 1;
13706
13707 device_param->device_processor_cores = device_processor_cores;
13708 }
13709 }
13710
13711 // display results
13712
13713 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13714 {
13715 if (status_automat == 0)
13716 {
13717 if (device_param->skipped == 0)
13718 {
13719 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13720 device_id + 1,
13721 device_name,
13722 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13723 (unsigned int) (device_global_mem / 1024 / 1024),
13724 (unsigned int) (device_maxclock_frequency),
13725 (unsigned int) device_processors);
13726 }
13727 else
13728 {
13729 log_info ("Device #%u: %s, skipped",
13730 device_id + 1,
13731 device_name);
13732 }
13733 }
13734 }
13735
13736 // common driver check
13737
13738 if (device_param->skipped == 0)
13739 {
13740 if (device_type & CL_DEVICE_TYPE_GPU)
13741 {
13742 if (platform_vendor_id == VENDOR_ID_AMD)
13743 {
13744 int catalyst_check = (force == 1) ? 0 : 1;
13745
13746 int catalyst_warn = 0;
13747
13748 int catalyst_broken = 0;
13749
13750 if (catalyst_check == 1)
13751 {
13752 catalyst_warn = 1;
13753
13754 // v14.9 and higher
13755 if (atoi (device_param->driver_version) >= 1573)
13756 {
13757 catalyst_warn = 0;
13758 }
13759
13760 catalyst_check = 0;
13761 }
13762
13763 if (catalyst_broken == 1)
13764 {
13765 log_info ("");
13766 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13767 log_info ("It will pass over cracked hashes and does not report them as cracked");
13768 log_info ("You are STRONGLY encouraged not to use it");
13769 log_info ("You can use --force to override this but do not post error reports if you do so");
13770 log_info ("");
13771
13772 return (-1);
13773 }
13774
13775 if (catalyst_warn == 1)
13776 {
13777 log_info ("");
13778 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13779 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13780 log_info ("See hashcat's homepage for official supported catalyst drivers");
13781 #ifdef _WIN
13782 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13783 #endif
13784 log_info ("You can use --force to override this but do not post error reports if you do so");
13785 log_info ("");
13786
13787 return (-1);
13788 }
13789 }
13790 else if (platform_vendor_id == VENDOR_ID_NV)
13791 {
13792 if (device_param->kernel_exec_timeout != 0)
13793 {
13794 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);
13795 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13796 }
13797 }
13798 }
13799
13800 /* turns out pocl still creates segfaults (because of llvm)
13801 if (device_type & CL_DEVICE_TYPE_CPU)
13802 {
13803 if (platform_vendor_id == VENDOR_ID_AMD)
13804 {
13805 if (force == 0)
13806 {
13807 log_info ("");
13808 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13809 log_info ("You are STRONGLY encouraged not to use it");
13810 log_info ("You can use --force to override this but do not post error reports if you do so");
13811 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13812 log_info ("");
13813
13814 return (-1);
13815 }
13816 }
13817 }
13818 */
13819
13820 /**
13821 * kernel accel and loops tuning db adjustment
13822 */
13823
13824 device_param->kernel_accel_min = 1;
13825 device_param->kernel_accel_max = 1024;
13826
13827 device_param->kernel_loops_min = 1;
13828 device_param->kernel_loops_max = 1024;
13829
13830 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13831
13832 if (tuningdb_entry)
13833 {
13834 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13835 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13836
13837 if (_kernel_accel)
13838 {
13839 device_param->kernel_accel_min = _kernel_accel;
13840 device_param->kernel_accel_max = _kernel_accel;
13841 }
13842
13843 if (_kernel_loops)
13844 {
13845 if (workload_profile == 1)
13846 {
13847 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13848 }
13849 else if (workload_profile == 2)
13850 {
13851 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13852 }
13853
13854 device_param->kernel_loops_min = _kernel_loops;
13855 device_param->kernel_loops_max = _kernel_loops;
13856 }
13857 }
13858
13859 // commandline parameters overwrite tuningdb entries
13860
13861 if (kernel_accel)
13862 {
13863 device_param->kernel_accel_min = kernel_accel;
13864 device_param->kernel_accel_max = kernel_accel;
13865 }
13866
13867 if (kernel_loops)
13868 {
13869 device_param->kernel_loops_min = kernel_loops;
13870 device_param->kernel_loops_max = kernel_loops;
13871 }
13872
13873 /**
13874 * activate device
13875 */
13876
13877 devices_active++;
13878 }
13879
13880 // next please
13881
13882 devices_cnt++;
13883 }
13884 }
13885
13886 if (keyspace == 0 && devices_active == 0)
13887 {
13888 log_error ("ERROR: No devices found/left");
13889
13890 return (-1);
13891 }
13892
13893 // 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)
13894
13895 if (devices_filter != (uint) -1)
13896 {
13897 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13898
13899 if (devices_filter > devices_cnt_mask)
13900 {
13901 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13902
13903 return (-1);
13904 }
13905 }
13906
13907 data.devices_cnt = devices_cnt;
13908
13909 data.devices_active = devices_active;
13910
13911 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13912 {
13913 if (status_automat == 0)
13914 {
13915 log_info ("");
13916 }
13917 }
13918
13919 /**
13920 * HM devices: init
13921 */
13922
13923 #ifdef HAVE_HWMON
13924 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13925 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13926 #endif
13927
13928 #ifdef HAVE_ADL
13929 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13930 #endif
13931
13932 if (gpu_temp_disable == 0)
13933 {
13934 #if defined(WIN) && defined(HAVE_NVAPI)
13935 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13936
13937 if (nvapi_init (nvapi) == 0)
13938 data.hm_nv = nvapi;
13939
13940 if (data.hm_nv)
13941 {
13942 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13943 {
13944 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13945
13946 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13947
13948 int tmp_out = 0;
13949
13950 for (int i = 0; i < tmp_in; i++)
13951 {
13952 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13953 }
13954
13955 for (int i = 0; i < tmp_out; i++)
13956 {
13957 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13958
13959 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13960
13961 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13962 }
13963 }
13964 }
13965 #endif // WIN && HAVE_NVAPI
13966
13967 #if defined(LINUX) && defined(HAVE_NVML)
13968 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13969
13970 if (nvml_init (nvml) == 0)
13971 data.hm_nv = nvml;
13972
13973 if (data.hm_nv)
13974 {
13975 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13976 {
13977 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13978
13979 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13980
13981 int tmp_out = 0;
13982
13983 for (int i = 0; i < tmp_in; i++)
13984 {
13985 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13986 }
13987
13988 for (int i = 0; i < tmp_out; i++)
13989 {
13990 unsigned int speed;
13991
13992 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13993 }
13994 }
13995 }
13996 #endif // LINUX && HAVE_NVML
13997
13998 data.hm_amd = NULL;
13999
14000 #ifdef HAVE_ADL
14001 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14002
14003 if (adl_init (adl) == 0)
14004 data.hm_amd = adl;
14005
14006 if (data.hm_amd)
14007 {
14008 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14009 {
14010 // total number of adapters
14011
14012 int hm_adapters_num;
14013
14014 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14015
14016 // adapter info
14017
14018 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14019
14020 if (lpAdapterInfo == NULL) return (-1);
14021
14022 // get a list (of ids of) valid/usable adapters
14023
14024 int num_adl_adapters = 0;
14025
14026 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14027
14028 if (num_adl_adapters > 0)
14029 {
14030 hc_thread_mutex_lock (mux_adl);
14031
14032 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14033
14034 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14035
14036 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14037 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14038
14039 hc_thread_mutex_unlock (mux_adl);
14040 }
14041
14042 myfree (valid_adl_device_list);
14043 myfree (lpAdapterInfo);
14044 }
14045 }
14046 #endif // HAVE_ADL
14047
14048 if (data.hm_amd == NULL && data.hm_nv == NULL)
14049 {
14050 gpu_temp_disable = 1;
14051 }
14052 }
14053
14054 /**
14055 * OpenCL devices: allocate buffer for device specific information
14056 */
14057
14058 #ifdef HAVE_HWMON
14059 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14060
14061 #ifdef HAVE_ADL
14062 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14063
14064 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14065 #endif // ADL
14066 #endif
14067
14068 /**
14069 * enable custom signal handler(s)
14070 */
14071
14072 if (benchmark == 0)
14073 {
14074 hc_signal (sigHandler_default);
14075 }
14076 else
14077 {
14078 hc_signal (sigHandler_benchmark);
14079 }
14080
14081 /**
14082 * User-defined GPU temp handling
14083 */
14084
14085 #ifdef HAVE_HWMON
14086 if (gpu_temp_disable == 1)
14087 {
14088 gpu_temp_abort = 0;
14089 gpu_temp_retain = 0;
14090 }
14091
14092 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14093 {
14094 if (gpu_temp_abort < gpu_temp_retain)
14095 {
14096 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14097
14098 return (-1);
14099 }
14100 }
14101
14102 data.gpu_temp_disable = gpu_temp_disable;
14103 data.gpu_temp_abort = gpu_temp_abort;
14104 data.gpu_temp_retain = gpu_temp_retain;
14105 #endif
14106
14107 /**
14108 * inform the user
14109 */
14110
14111 if (data.quiet == 0)
14112 {
14113 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14114
14115 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);
14116
14117 if (attack_mode == ATTACK_MODE_STRAIGHT)
14118 {
14119 log_info ("Rules: %u", kernel_rules_cnt);
14120 }
14121
14122 if (opti_type)
14123 {
14124 log_info ("Applicable Optimizers:");
14125
14126 for (uint i = 0; i < 32; i++)
14127 {
14128 const uint opti_bit = 1u << i;
14129
14130 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14131 }
14132 }
14133
14134 /**
14135 * Watchdog and Temperature balance
14136 */
14137
14138 #ifdef HAVE_HWMON
14139 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14140 {
14141 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14142 }
14143
14144 if (gpu_temp_abort == 0)
14145 {
14146 log_info ("Watchdog: Temperature abort trigger disabled");
14147 }
14148 else
14149 {
14150 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14151 }
14152
14153 if (gpu_temp_retain == 0)
14154 {
14155 log_info ("Watchdog: Temperature retain trigger disabled");
14156 }
14157 else
14158 {
14159 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14160 }
14161
14162 if (data.quiet == 0) log_info ("");
14163 #endif
14164 }
14165
14166 /**
14167 * HM devices: copy
14168 */
14169
14170 if (gpu_temp_disable == 0)
14171 {
14172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14173 {
14174 hc_device_param_t *device_param = &data.devices_param[device_id];
14175
14176 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14177
14178 if (device_param->skipped) continue;
14179
14180 const uint platform_devices_id = device_param->platform_devices_id;
14181
14182 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14183 if (device_param->device_vendor_id == VENDOR_ID_NV)
14184 {
14185 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14186 }
14187 #endif
14188
14189 #ifdef HAVE_ADL
14190 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14191 {
14192 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14193 }
14194 #endif
14195 }
14196 }
14197
14198 /*
14199 * Temporary fix:
14200 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14201 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14202 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14203 * Driver / ADL bug?
14204 */
14205
14206 #ifdef HAVE_ADL
14207 if (powertune_enable == 1)
14208 {
14209 hc_thread_mutex_lock (mux_adl);
14210
14211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14212 {
14213 hc_device_param_t *device_param = &data.devices_param[device_id];
14214
14215 if (device_param->skipped) continue;
14216
14217 if (data.hm_device[device_id].od_version == 6)
14218 {
14219 // set powertune value only
14220
14221 int powertune_supported = 0;
14222
14223 int ADL_rc = 0;
14224
14225 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14226 {
14227 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14228
14229 return (-1);
14230 }
14231
14232 if (powertune_supported != 0)
14233 {
14234 // powertune set
14235 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14236
14237 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14238 {
14239 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14240
14241 return (-1);
14242 }
14243
14244 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14245 {
14246 log_error ("ERROR: Failed to set new ADL PowerControl values");
14247
14248 return (-1);
14249 }
14250 }
14251 }
14252 }
14253
14254 hc_thread_mutex_unlock (mux_adl);
14255 }
14256 #endif // HAVE_ADK
14257 #endif // HAVE_HWMON
14258
14259 #ifdef DEBUG
14260 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14261 #endif
14262
14263 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14264
14265 uint kernel_power_all = 0;
14266
14267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14268 {
14269 /**
14270 * host buffer
14271 */
14272
14273 hc_device_param_t *device_param = &data.devices_param[device_id];
14274
14275 if (device_param->skipped) continue;
14276
14277 /**
14278 * device properties
14279 */
14280
14281 const char *device_name_chksum = device_param->device_name_chksum;
14282 const u32 device_processors = device_param->device_processors;
14283 const u32 device_processor_cores = device_param->device_processor_cores;
14284
14285 /**
14286 * create context for each device
14287 */
14288
14289 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14290
14291 /**
14292 * create command-queue
14293 */
14294
14295 // not supported with NV
14296 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14297
14298 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14299
14300 /**
14301 * kernel threads: some algorithms need a fixed kernel-threads count
14302 * because of shared memory usage or bitslice
14303 * there needs to be some upper limit, otherwise there's too much overhead
14304 */
14305
14306 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14307
14308 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14309 {
14310 kernel_threads = KERNEL_THREADS_MAX_CPU;
14311 }
14312
14313 if (hash_mode == 1500) kernel_threads = 64; // DES
14314 if (hash_mode == 3000) kernel_threads = 64; // DES
14315 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14316 if (hash_mode == 7500) kernel_threads = 64; // RC4
14317 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14318 if (hash_mode == 9700) kernel_threads = 64; // RC4
14319 if (hash_mode == 9710) kernel_threads = 64; // RC4
14320 if (hash_mode == 9800) kernel_threads = 64; // RC4
14321 if (hash_mode == 9810) kernel_threads = 64; // RC4
14322 if (hash_mode == 10400) kernel_threads = 64; // RC4
14323 if (hash_mode == 10410) kernel_threads = 64; // RC4
14324 if (hash_mode == 10500) kernel_threads = 64; // RC4
14325 if (hash_mode == 13100) kernel_threads = 64; // RC4
14326
14327 /**
14328 * create input buffers on device : calculate size of fixed memory buffers
14329 */
14330
14331 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14332 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14333
14334 device_param->size_root_css = size_root_css;
14335 device_param->size_markov_css = size_markov_css;
14336
14337 size_t size_results = sizeof (uint);
14338
14339 device_param->size_results = size_results;
14340
14341 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14342 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14343
14344 size_t size_plains = digests_cnt * sizeof (plain_t);
14345 size_t size_salts = salts_cnt * sizeof (salt_t);
14346 size_t size_esalts = salts_cnt * esalt_size;
14347
14348 device_param->size_plains = size_plains;
14349 device_param->size_digests = size_digests;
14350 device_param->size_shown = size_shown;
14351 device_param->size_salts = size_salts;
14352
14353 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14354 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14355 size_t size_tm = 32 * sizeof (bs_word_t);
14356
14357 // scryptV stuff
14358
14359 size_t size_scryptV = 1;
14360
14361 if ((hash_mode == 8900) || (hash_mode == 9300))
14362 {
14363 uint tmto_start = 0;
14364 uint tmto_stop = 10;
14365
14366 if (scrypt_tmto)
14367 {
14368 tmto_start = scrypt_tmto;
14369 }
14370 else
14371 {
14372 // in case the user did not specify the tmto manually
14373 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14374 // but set the lower end only in case the user has a device with too less memory
14375
14376 if (hash_mode == 8900)
14377 {
14378 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14379 {
14380 tmto_start = 1;
14381 }
14382 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14383 {
14384 tmto_start = 2;
14385 }
14386 }
14387 else if (hash_mode == 9300)
14388 {
14389 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14390 {
14391 tmto_start = 2;
14392 }
14393 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14394 {
14395 tmto_start = 2;
14396 }
14397 }
14398 }
14399
14400 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14401 {
14402 // TODO: in theory the following calculation needs to be done per salt, not global
14403 // we assume all hashes have the same scrypt settings
14404
14405 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14406
14407 size_scryptV /= 1 << tmto;
14408
14409 size_scryptV *= device_processors * device_processor_cores;
14410
14411 if (size_scryptV > device_param->device_maxmem_alloc)
14412 {
14413 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14414
14415 continue;
14416 }
14417
14418 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14419 {
14420 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14421 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14422 }
14423
14424 break;
14425 }
14426
14427 if (data.salts_buf[0].scrypt_phy == 0)
14428 {
14429 log_error ("ERROR: can't allocate enough device memory");
14430
14431 return -1;
14432 }
14433
14434 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14435 }
14436
14437 /**
14438 * some algorithms need a fixed kernel-loops count
14439 */
14440
14441 if (hash_mode == 1500)
14442 {
14443 const u32 kernel_loops_fixed = 1024;
14444
14445 device_param->kernel_loops_min = kernel_loops_fixed;
14446 device_param->kernel_loops_max = kernel_loops_fixed;
14447 }
14448
14449 if (hash_mode == 3000)
14450 {
14451 const u32 kernel_loops_fixed = 1024;
14452
14453 device_param->kernel_loops_min = kernel_loops_fixed;
14454 device_param->kernel_loops_max = kernel_loops_fixed;
14455 }
14456
14457 if (hash_mode == 8900)
14458 {
14459 const u32 kernel_loops_fixed = 1;
14460
14461 device_param->kernel_loops_min = kernel_loops_fixed;
14462 device_param->kernel_loops_max = kernel_loops_fixed;
14463 }
14464
14465 if (hash_mode == 9300)
14466 {
14467 const u32 kernel_loops_fixed = 1;
14468
14469 device_param->kernel_loops_min = kernel_loops_fixed;
14470 device_param->kernel_loops_max = kernel_loops_fixed;
14471 }
14472
14473 if (hash_mode == 12500)
14474 {
14475 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14476
14477 device_param->kernel_loops_min = kernel_loops_fixed;
14478 device_param->kernel_loops_max = kernel_loops_fixed;
14479 }
14480
14481 /**
14482 * some algorithms have a maximum kernel-loops count
14483 */
14484
14485 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14486 {
14487 u32 innerloop_cnt = 0;
14488
14489 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14490 {
14491 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14492 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14493 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14494 }
14495 else
14496 {
14497 innerloop_cnt = data.salts_buf[0].salt_iter;
14498 }
14499
14500 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14501 (innerloop_cnt <= device_param->kernel_loops_max))
14502 {
14503 device_param->kernel_loops_max = innerloop_cnt;
14504 }
14505 }
14506
14507 u32 kernel_accel_min = device_param->kernel_accel_min;
14508 u32 kernel_accel_max = device_param->kernel_accel_max;
14509
14510 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14511
14512 size_t size_pws = 4;
14513 size_t size_tmps = 4;
14514 size_t size_hooks = 4;
14515
14516 while (kernel_accel_max >= kernel_accel_min)
14517 {
14518 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14519
14520 // size_pws
14521
14522 size_pws = kernel_power_max * sizeof (pw_t);
14523
14524 // size_tmps
14525
14526 switch (hash_mode)
14527 {
14528 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14529 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14530 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14531 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14532 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14533 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14534 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14535 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14536 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14537 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14538 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14539 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14540 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14541 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14542 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14543 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14544 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14545 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14546 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14547 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14548 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14549 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14550 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14551 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14552 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14553 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14554 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14555 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14556 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14557 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14558 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14559 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14560 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14561 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14562 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14563 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14564 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14565 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14566 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14567 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14568 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14569 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14570 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14571 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14572 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14573 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14574 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14575 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14576 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14577 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14578 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14579 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14580 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14581 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14582 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14583 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14584 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14585 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14586 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14587 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14588 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14589 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14590 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14591 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14592 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14593 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14594 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14595 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14596 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14597 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14598 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14599 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14600 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14601 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14602 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14603 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14604 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14605 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14606 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14607 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14608 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14609 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14610 };
14611
14612 // size_hooks
14613
14614 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14615 {
14616 // none yet
14617 }
14618
14619 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14620 // if not, decrease amplifier and try again
14621
14622 int skip = 0;
14623
14624 const u64 size_total
14625 = bitmap_size
14626 + bitmap_size
14627 + bitmap_size
14628 + bitmap_size
14629 + bitmap_size
14630 + bitmap_size
14631 + bitmap_size
14632 + bitmap_size
14633 + size_bfs
14634 + size_combs
14635 + size_digests
14636 + size_esalts
14637 + size_hooks
14638 + size_markov_css
14639 + size_plains
14640 + size_pws
14641 + size_pws // not a bug
14642 + size_results
14643 + size_root_css
14644 + size_rules
14645 + size_rules_c
14646 + size_salts
14647 + size_scryptV
14648 + size_shown
14649 + size_tm
14650 + size_tmps;
14651
14652 // Don't ask me, ask AMD!
14653
14654 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14655 if (size_total > device_param->device_global_mem) skip = 1;
14656
14657 if (skip == 1)
14658 {
14659 kernel_accel_max--;
14660
14661 continue;
14662 }
14663
14664 break;
14665 }
14666
14667 /*
14668 if (kernel_accel_max == 0)
14669 {
14670 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14671
14672 return -1;
14673 }
14674 */
14675
14676 device_param->kernel_accel_min = kernel_accel_min;
14677 device_param->kernel_accel_max = kernel_accel_max;
14678
14679 /*
14680 if (kernel_accel_max < kernel_accel)
14681 {
14682 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14683
14684 device_param->kernel_accel = kernel_accel_max;
14685 }
14686 */
14687
14688 device_param->size_bfs = size_bfs;
14689 device_param->size_combs = size_combs;
14690 device_param->size_rules = size_rules;
14691 device_param->size_rules_c = size_rules_c;
14692 device_param->size_pws = size_pws;
14693 device_param->size_tmps = size_tmps;
14694 device_param->size_hooks = size_hooks;
14695
14696 // do not confuse kernel_accel_max with kernel_accel here
14697
14698 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14699
14700 device_param->kernel_threads = kernel_threads;
14701 device_param->kernel_power_user = kernel_power;
14702
14703 kernel_power_all += kernel_power;
14704
14705 /**
14706 * default building options
14707 */
14708
14709 char build_opts[1024] = { 0 };
14710
14711 // we don't have sm_* on vendors not NV but it doesn't matter
14712
14713 #if _WIN
14714 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);
14715 #else
14716 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);
14717 #endif
14718
14719 char build_opts_new[1024] = { 0 };
14720
14721 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);
14722
14723 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14724
14725 /*
14726 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14727 {
14728 // we do vectorizing much better than the auto-vectorizer
14729
14730 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14731
14732 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14733 }
14734 */
14735
14736 #ifdef DEBUG
14737 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14738 #endif
14739
14740 /**
14741 * main kernel
14742 */
14743
14744 {
14745 /**
14746 * kernel source filename
14747 */
14748
14749 char source_file[256] = { 0 };
14750
14751 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14752
14753 struct stat sst;
14754
14755 if (stat (source_file, &sst) == -1)
14756 {
14757 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14758
14759 return -1;
14760 }
14761
14762 /**
14763 * kernel cached filename
14764 */
14765
14766 char cached_file[256] = { 0 };
14767
14768 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14769
14770 int cached = 1;
14771
14772 struct stat cst;
14773
14774 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14775 {
14776 cached = 0;
14777 }
14778
14779 /**
14780 * kernel compile or load
14781 */
14782
14783 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14784
14785 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14786
14787 if (force_jit_compilation == -1)
14788 {
14789 if (cached == 0)
14790 {
14791 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14792
14793 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14794
14795 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14796
14797 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14798
14799 #ifdef DEBUG
14800 size_t build_log_size = 0;
14801
14802 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14803
14804 if (build_log_size > 1)
14805 {
14806 char *build_log = (char *) malloc (build_log_size + 1);
14807
14808 memset (build_log, 0, build_log_size + 1);
14809
14810 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14811
14812 puts (build_log);
14813
14814 free (build_log);
14815 }
14816 #endif
14817
14818 if (rc != 0)
14819 {
14820 device_param->skipped = true;
14821
14822 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14823
14824 continue;
14825 }
14826
14827 size_t binary_size;
14828
14829 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14830
14831 u8 *binary = (u8 *) mymalloc (binary_size);
14832
14833 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14834
14835 writeProgramBin (cached_file, binary, binary_size);
14836
14837 local_free (binary);
14838 }
14839 else
14840 {
14841 #ifdef DEBUG
14842 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14843 #endif
14844
14845 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14846
14847 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14848
14849 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14850 }
14851 }
14852 else
14853 {
14854 #ifdef DEBUG
14855 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14856 #endif
14857
14858 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14859
14860 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14861
14862 char build_opts_update[1024] = { 0 };
14863
14864 if (force_jit_compilation == 1500)
14865 {
14866 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14867 }
14868 else if (force_jit_compilation == 8900)
14869 {
14870 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);
14871 }
14872 else
14873 {
14874 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14875 }
14876
14877 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14878
14879 #ifdef DEBUG
14880 size_t build_log_size = 0;
14881
14882 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14883
14884 if (build_log_size > 1)
14885 {
14886 char *build_log = (char *) malloc (build_log_size + 1);
14887
14888 memset (build_log, 0, build_log_size + 1);
14889
14890 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14891
14892 puts (build_log);
14893
14894 free (build_log);
14895 }
14896 #endif
14897
14898 if (rc != 0)
14899 {
14900 device_param->skipped = true;
14901
14902 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14903 }
14904 }
14905
14906 local_free (kernel_lengths);
14907 local_free (kernel_sources[0]);
14908 local_free (kernel_sources);
14909 }
14910
14911 /**
14912 * word generator kernel
14913 */
14914
14915 if (attack_mode != ATTACK_MODE_STRAIGHT)
14916 {
14917 /**
14918 * kernel mp source filename
14919 */
14920
14921 char source_file[256] = { 0 };
14922
14923 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14924
14925 struct stat sst;
14926
14927 if (stat (source_file, &sst) == -1)
14928 {
14929 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14930
14931 return -1;
14932 }
14933
14934 /**
14935 * kernel mp cached filename
14936 */
14937
14938 char cached_file[256] = { 0 };
14939
14940 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14941
14942 int cached = 1;
14943
14944 struct stat cst;
14945
14946 if (stat (cached_file, &cst) == -1)
14947 {
14948 cached = 0;
14949 }
14950
14951 /**
14952 * kernel compile or load
14953 */
14954
14955 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14956
14957 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14958
14959 if (cached == 0)
14960 {
14961 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14962 if (quiet == 0) log_info ("");
14963
14964 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14965
14966 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14967
14968 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14969
14970 if (rc != 0)
14971 {
14972 device_param->skipped = true;
14973
14974 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14975
14976 continue;
14977 }
14978
14979 size_t binary_size;
14980
14981 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14982
14983 u8 *binary = (u8 *) mymalloc (binary_size);
14984
14985 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14986
14987 writeProgramBin (cached_file, binary, binary_size);
14988
14989 local_free (binary);
14990 }
14991 else
14992 {
14993 #ifdef DEBUG
14994 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14995 #endif
14996
14997 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14998
14999 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15000
15001 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15002 }
15003
15004 local_free (kernel_lengths);
15005 local_free (kernel_sources[0]);
15006 local_free (kernel_sources);
15007 }
15008
15009 /**
15010 * amplifier kernel
15011 */
15012
15013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15014 {
15015
15016 }
15017 else
15018 {
15019 /**
15020 * kernel amp source filename
15021 */
15022
15023 char source_file[256] = { 0 };
15024
15025 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15026
15027 struct stat sst;
15028
15029 if (stat (source_file, &sst) == -1)
15030 {
15031 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15032
15033 return -1;
15034 }
15035
15036 /**
15037 * kernel amp cached filename
15038 */
15039
15040 char cached_file[256] = { 0 };
15041
15042 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15043
15044 int cached = 1;
15045
15046 struct stat cst;
15047
15048 if (stat (cached_file, &cst) == -1)
15049 {
15050 cached = 0;
15051 }
15052
15053 /**
15054 * kernel compile or load
15055 */
15056
15057 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15058
15059 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15060
15061 if (cached == 0)
15062 {
15063 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15064 if (quiet == 0) log_info ("");
15065
15066 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15067
15068 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15069
15070 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15071
15072 if (rc != 0)
15073 {
15074 device_param->skipped = true;
15075
15076 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15077
15078 continue;
15079 }
15080
15081 size_t binary_size;
15082
15083 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15084
15085 u8 *binary = (u8 *) mymalloc (binary_size);
15086
15087 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15088
15089 writeProgramBin (cached_file, binary, binary_size);
15090
15091 local_free (binary);
15092 }
15093 else
15094 {
15095 #ifdef DEBUG
15096 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15097 #endif
15098
15099 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15100
15101 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15102
15103 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15104 }
15105
15106 local_free (kernel_lengths);
15107 local_free (kernel_sources[0]);
15108 local_free (kernel_sources);
15109 }
15110
15111 // some algorithm collide too fast, make that impossible
15112
15113 if (benchmark == 1)
15114 {
15115 ((uint *) digests_buf)[0] = -1;
15116 ((uint *) digests_buf)[1] = -1;
15117 ((uint *) digests_buf)[2] = -1;
15118 ((uint *) digests_buf)[3] = -1;
15119 }
15120
15121 /**
15122 * global buffers
15123 */
15124
15125 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15126 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15127 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15128 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15129 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15130 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15131 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15132 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15133 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15134 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15135 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15136 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15137 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15138 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15139 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15140 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15141 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15142 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15143
15144 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);
15145 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);
15146 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);
15147 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);
15148 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);
15149 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);
15150 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);
15151 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);
15152 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15153 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15154 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15155
15156 /**
15157 * special buffers
15158 */
15159
15160 if (attack_kern == ATTACK_KERN_STRAIGHT)
15161 {
15162 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15163 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15164
15165 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15166 }
15167 else if (attack_kern == ATTACK_KERN_COMBI)
15168 {
15169 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15170 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15171 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15172 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15173 }
15174 else if (attack_kern == ATTACK_KERN_BF)
15175 {
15176 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15177 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15178 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15179 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15180 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15181 }
15182
15183 if (size_esalts)
15184 {
15185 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15186
15187 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15188 }
15189
15190 /**
15191 * main host data
15192 */
15193
15194 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15195
15196 device_param->pws_buf = pws_buf;
15197
15198 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15199
15200 device_param->combs_buf = combs_buf;
15201
15202 void *hooks_buf = mymalloc (size_hooks);
15203
15204 device_param->hooks_buf = hooks_buf;
15205
15206 /**
15207 * kernel args
15208 */
15209
15210 device_param->kernel_params_buf32[21] = bitmap_mask;
15211 device_param->kernel_params_buf32[22] = bitmap_shift1;
15212 device_param->kernel_params_buf32[23] = bitmap_shift2;
15213 device_param->kernel_params_buf32[24] = 0; // salt_pos
15214 device_param->kernel_params_buf32[25] = 0; // loop_pos
15215 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15216 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15217 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15218 device_param->kernel_params_buf32[29] = 0; // digests_offset
15219 device_param->kernel_params_buf32[30] = 0; // combs_mode
15220 device_param->kernel_params_buf32[31] = 0; // gid_max
15221
15222 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15223 ? &device_param->d_pws_buf
15224 : &device_param->d_pws_amp_buf;
15225 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15226 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15227 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15228 device_param->kernel_params[ 4] = &device_param->d_tmps;
15229 device_param->kernel_params[ 5] = &device_param->d_hooks;
15230 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15231 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15232 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15233 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15234 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15235 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15236 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15237 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15238 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15239 device_param->kernel_params[15] = &device_param->d_digests_buf;
15240 device_param->kernel_params[16] = &device_param->d_digests_shown;
15241 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15242 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15243 device_param->kernel_params[19] = &device_param->d_result;
15244 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15245 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15246 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15247 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15248 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15249 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15250 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15251 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15252 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15253 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15254 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15255 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15256
15257 device_param->kernel_params_mp_buf64[3] = 0;
15258 device_param->kernel_params_mp_buf32[4] = 0;
15259 device_param->kernel_params_mp_buf32[5] = 0;
15260 device_param->kernel_params_mp_buf32[6] = 0;
15261 device_param->kernel_params_mp_buf32[7] = 0;
15262 device_param->kernel_params_mp_buf32[8] = 0;
15263
15264 device_param->kernel_params_mp[0] = NULL;
15265 device_param->kernel_params_mp[1] = NULL;
15266 device_param->kernel_params_mp[2] = NULL;
15267 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15268 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15269 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15270 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15271 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15272 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15273
15274 device_param->kernel_params_mp_l_buf64[3] = 0;
15275 device_param->kernel_params_mp_l_buf32[4] = 0;
15276 device_param->kernel_params_mp_l_buf32[5] = 0;
15277 device_param->kernel_params_mp_l_buf32[6] = 0;
15278 device_param->kernel_params_mp_l_buf32[7] = 0;
15279 device_param->kernel_params_mp_l_buf32[8] = 0;
15280 device_param->kernel_params_mp_l_buf32[9] = 0;
15281
15282 device_param->kernel_params_mp_l[0] = NULL;
15283 device_param->kernel_params_mp_l[1] = NULL;
15284 device_param->kernel_params_mp_l[2] = NULL;
15285 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15286 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15287 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15288 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15289 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15290 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15291 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15292
15293 device_param->kernel_params_mp_r_buf64[3] = 0;
15294 device_param->kernel_params_mp_r_buf32[4] = 0;
15295 device_param->kernel_params_mp_r_buf32[5] = 0;
15296 device_param->kernel_params_mp_r_buf32[6] = 0;
15297 device_param->kernel_params_mp_r_buf32[7] = 0;
15298 device_param->kernel_params_mp_r_buf32[8] = 0;
15299
15300 device_param->kernel_params_mp_r[0] = NULL;
15301 device_param->kernel_params_mp_r[1] = NULL;
15302 device_param->kernel_params_mp_r[2] = NULL;
15303 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15304 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15305 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15306 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15307 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15308 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15309
15310 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15311 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15312
15313 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15314 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15315 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15316 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15317 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15318 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15319 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15320
15321 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15322 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15323
15324 device_param->kernel_params_memset_buf32[1] = 0; // value
15325 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15326
15327 device_param->kernel_params_memset[0] = NULL;
15328 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15329 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15330
15331 /**
15332 * kernel name
15333 */
15334
15335 size_t kernel_wgs_tmp;
15336
15337 char kernel_name[64] = { 0 };
15338
15339 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15340 {
15341 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15342 {
15343 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15344
15345 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15346
15347 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15348
15349 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15350
15351 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15352
15353 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15354 }
15355 else
15356 {
15357 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15358
15359 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15360
15361 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15362
15363 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15364
15365 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15366
15367 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15368 }
15369
15370 if (data.attack_mode == ATTACK_MODE_BF)
15371 {
15372 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15373 {
15374 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15375
15376 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15377
15378 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);
15379 }
15380 }
15381 }
15382 else
15383 {
15384 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15385
15386 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15387
15388 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15389
15390 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15391
15392 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15393
15394 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15395
15396 if (opts_type & OPTS_TYPE_HOOK12)
15397 {
15398 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15399
15400 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15401
15402 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);
15403 }
15404
15405 if (opts_type & OPTS_TYPE_HOOK23)
15406 {
15407 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15408
15409 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15410
15411 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);
15412 }
15413 }
15414
15415 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);
15416 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);
15417 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);
15418
15419 for (uint i = 0; i <= 20; i++)
15420 {
15421 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15422 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15423 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15424
15425 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15426 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15427 }
15428
15429 for (uint i = 21; i <= 31; i++)
15430 {
15431 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15432 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15433 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15434
15435 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15436 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15437 }
15438
15439 // GPU memset
15440
15441 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15442
15443 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);
15444
15445 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15446 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15447 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15448
15449 // MP start
15450
15451 if (attack_mode == ATTACK_MODE_BF)
15452 {
15453 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15454 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15455
15456 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);
15457 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);
15458
15459 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15460 {
15461 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15462 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15463 }
15464 }
15465 else if (attack_mode == ATTACK_MODE_HYBRID1)
15466 {
15467 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15468
15469 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);
15470 }
15471 else if (attack_mode == ATTACK_MODE_HYBRID2)
15472 {
15473 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15474
15475 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);
15476 }
15477
15478 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15479 {
15480 // nothing to do
15481 }
15482 else
15483 {
15484 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15485
15486 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);
15487 }
15488
15489 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15490 {
15491 // nothing to do
15492 }
15493 else
15494 {
15495 for (uint i = 0; i < 5; i++)
15496 {
15497 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15498 }
15499
15500 for (uint i = 5; i < 7; i++)
15501 {
15502 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15503 }
15504 }
15505
15506 // maybe this has been updated by clGetKernelWorkGroupInfo()
15507 // value can only be decreased, so we don't need to reallocate buffers
15508
15509 device_param->kernel_threads = kernel_threads;
15510
15511 // zero some data buffers
15512
15513 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15514 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15515 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15516 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15517 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15518 run_kernel_bzero (device_param, device_param->d_result, size_results);
15519
15520 /**
15521 * special buffers
15522 */
15523
15524 if (attack_kern == ATTACK_KERN_STRAIGHT)
15525 {
15526 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15527 }
15528 else if (attack_kern == ATTACK_KERN_COMBI)
15529 {
15530 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15531 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15532 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15533 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15534 }
15535 else if (attack_kern == ATTACK_KERN_BF)
15536 {
15537 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15538 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15539 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15540 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15541 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15542 }
15543
15544 /**
15545 * Store initial fanspeed if gpu_temp_retain is enabled
15546 */
15547
15548 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15549 int gpu_temp_retain_set = 0;
15550
15551 if (gpu_temp_disable == 0)
15552 {
15553 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15554 {
15555 hc_thread_mutex_lock (mux_adl);
15556
15557 if (data.hm_device[device_id].fan_supported == 1)
15558 {
15559 if (gpu_temp_retain_chgd == 0)
15560 {
15561 uint cur_temp = 0;
15562 uint default_temp = 0;
15563
15564 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15565
15566 if (ADL_rc == ADL_OK)
15567 {
15568 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15569
15570 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15571
15572 // special case with multi gpu setups: always use minimum retain
15573
15574 if (gpu_temp_retain_set == 0)
15575 {
15576 gpu_temp_retain = gpu_temp_retain_target;
15577 gpu_temp_retain_set = 1;
15578 }
15579 else
15580 {
15581 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15582 }
15583
15584 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15585 }
15586 }
15587
15588 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15589
15590 temp_retain_fanspeed_value[device_id] = fan_speed;
15591
15592 if (fan_speed == -1)
15593 {
15594 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15595
15596 temp_retain_fanspeed_value[device_id] = 0;
15597 }
15598 }
15599
15600 hc_thread_mutex_unlock (mux_adl);
15601 }
15602 }
15603
15604 /**
15605 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15606 */
15607
15608 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15609 {
15610 hc_thread_mutex_lock (mux_adl);
15611
15612 if (data.hm_device[device_id].od_version == 6)
15613 {
15614 int ADL_rc;
15615
15616 // check powertune capabilities first, if not available then skip device
15617
15618 int powertune_supported = 0;
15619
15620 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15621 {
15622 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15623
15624 return (-1);
15625 }
15626
15627 if (powertune_supported != 0)
15628 {
15629 // powercontrol settings
15630
15631 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15632
15633 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15634 {
15635 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15636 }
15637
15638 if (ADL_rc != ADL_OK)
15639 {
15640 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15641
15642 return (-1);
15643 }
15644
15645 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15646 {
15647 log_error ("ERROR: Failed to set new ADL PowerControl values");
15648
15649 return (-1);
15650 }
15651
15652 // clocks
15653
15654 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15655
15656 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15657
15658 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15659 {
15660 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15661
15662 return (-1);
15663 }
15664
15665 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15666
15667 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15668
15669 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15670 {
15671 log_error ("ERROR: Failed to get ADL device capabilities");
15672
15673 return (-1);
15674 }
15675
15676 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15677 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15678
15679 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15680 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15681
15682 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15683 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15684
15685 // warning if profile has too low max values
15686
15687 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15688 {
15689 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15690 }
15691
15692 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15693 {
15694 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15695 }
15696
15697 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15698
15699 performance_state->iNumberOfPerformanceLevels = 2;
15700
15701 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15702 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15703 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15704 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15705
15706 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15707 {
15708 log_info ("ERROR: Failed to set ADL performance state");
15709
15710 return (-1);
15711 }
15712
15713 local_free (performance_state);
15714 }
15715 }
15716
15717 hc_thread_mutex_unlock (mux_adl);
15718 }
15719 #endif // HAVE_HWMON && HAVE_ADL
15720 }
15721
15722 data.kernel_power_all = kernel_power_all;
15723
15724 if (data.quiet == 0) log_info_nn ("");
15725
15726 /**
15727 * In benchmark-mode, inform user which algorithm is checked
15728 */
15729
15730 if (benchmark == 1)
15731 {
15732 if (status_automat == 0)
15733 {
15734 quiet = 0;
15735
15736 data.quiet = quiet;
15737
15738 char *hash_type = strhashtype (data.hash_mode); // not a bug
15739
15740 log_info ("Hashtype: %s", hash_type);
15741 log_info ("");
15742 }
15743 }
15744
15745 /**
15746 * keep track of the progress
15747 */
15748
15749 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15750 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15751 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15752
15753 /**
15754 * open filehandles
15755 */
15756
15757 #if _WIN
15758 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15759 {
15760 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15761
15762 return (-1);
15763 }
15764
15765 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15766 {
15767 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15768
15769 return (-1);
15770 }
15771
15772 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15773 {
15774 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15775
15776 return (-1);
15777 }
15778 #endif
15779
15780 /**
15781 * dictionary pad
15782 */
15783
15784 segment_size *= (1024 * 1024);
15785
15786 data.segment_size = segment_size;
15787
15788 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15789
15790 wl_data->buf = (char *) mymalloc (segment_size);
15791 wl_data->avail = segment_size;
15792 wl_data->incr = segment_size;
15793 wl_data->cnt = 0;
15794 wl_data->pos = 0;
15795
15796 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15797
15798 data.wordlist_mode = wordlist_mode;
15799
15800 cs_t *css_buf = NULL;
15801 uint css_cnt = 0;
15802 uint dictcnt = 0;
15803 uint maskcnt = 1;
15804 char **masks = NULL;
15805 char **dictfiles = NULL;
15806
15807 uint mask_from_file = 0;
15808
15809 if (attack_mode == ATTACK_MODE_STRAIGHT)
15810 {
15811 if (wordlist_mode == WL_MODE_FILE)
15812 {
15813 int wls_left = myargc - (optind + 1);
15814
15815 for (int i = 0; i < wls_left; i++)
15816 {
15817 char *l0_filename = myargv[optind + 1 + i];
15818
15819 struct stat l0_stat;
15820
15821 if (stat (l0_filename, &l0_stat) == -1)
15822 {
15823 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15824
15825 return (-1);
15826 }
15827
15828 uint is_dir = S_ISDIR (l0_stat.st_mode);
15829
15830 if (is_dir == 0)
15831 {
15832 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15833
15834 dictcnt++;
15835
15836 dictfiles[dictcnt - 1] = l0_filename;
15837 }
15838 else
15839 {
15840 // do not allow --keyspace w/ a directory
15841
15842 if (keyspace == 1)
15843 {
15844 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15845
15846 return (-1);
15847 }
15848
15849 char **dictionary_files = NULL;
15850
15851 dictionary_files = scan_directory (l0_filename);
15852
15853 if (dictionary_files != NULL)
15854 {
15855 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15856
15857 for (int d = 0; dictionary_files[d] != NULL; d++)
15858 {
15859 char *l1_filename = dictionary_files[d];
15860
15861 struct stat l1_stat;
15862
15863 if (stat (l1_filename, &l1_stat) == -1)
15864 {
15865 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15866
15867 return (-1);
15868 }
15869
15870 if (S_ISREG (l1_stat.st_mode))
15871 {
15872 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15873
15874 dictcnt++;
15875
15876 dictfiles[dictcnt - 1] = strdup (l1_filename);
15877 }
15878 }
15879 }
15880
15881 local_free (dictionary_files);
15882 }
15883 }
15884
15885 if (dictcnt < 1)
15886 {
15887 log_error ("ERROR: No usable dictionary file found.");
15888
15889 return (-1);
15890 }
15891 }
15892 else if (wordlist_mode == WL_MODE_STDIN)
15893 {
15894 dictcnt = 1;
15895 }
15896 }
15897 else if (attack_mode == ATTACK_MODE_COMBI)
15898 {
15899 // display
15900
15901 char *dictfile1 = myargv[optind + 1 + 0];
15902 char *dictfile2 = myargv[optind + 1 + 1];
15903
15904 // find the bigger dictionary and use as base
15905
15906 FILE *fp1 = NULL;
15907 FILE *fp2 = NULL;
15908
15909 struct stat tmp_stat;
15910
15911 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15912 {
15913 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15914
15915 return (-1);
15916 }
15917
15918 if (stat (dictfile1, &tmp_stat) == -1)
15919 {
15920 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15921
15922 fclose (fp1);
15923
15924 return (-1);
15925 }
15926
15927 if (S_ISDIR (tmp_stat.st_mode))
15928 {
15929 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15930
15931 fclose (fp1);
15932
15933 return (-1);
15934 }
15935
15936 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15937 {
15938 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15939
15940 fclose (fp1);
15941
15942 return (-1);
15943 }
15944
15945 if (stat (dictfile2, &tmp_stat) == -1)
15946 {
15947 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15948
15949 fclose (fp1);
15950 fclose (fp2);
15951
15952 return (-1);
15953 }
15954
15955 if (S_ISDIR (tmp_stat.st_mode))
15956 {
15957 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15958
15959 fclose (fp1);
15960 fclose (fp2);
15961
15962 return (-1);
15963 }
15964
15965 data.combs_cnt = 1;
15966
15967 data.quiet = 1;
15968
15969 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15970
15971 data.quiet = quiet;
15972
15973 if (words1_cnt == 0)
15974 {
15975 log_error ("ERROR: %s: empty file", dictfile1);
15976
15977 fclose (fp1);
15978 fclose (fp2);
15979
15980 return (-1);
15981 }
15982
15983 data.combs_cnt = 1;
15984
15985 data.quiet = 1;
15986
15987 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15988
15989 data.quiet = quiet;
15990
15991 if (words2_cnt == 0)
15992 {
15993 log_error ("ERROR: %s: empty file", dictfile2);
15994
15995 fclose (fp1);
15996 fclose (fp2);
15997
15998 return (-1);
15999 }
16000
16001 fclose (fp1);
16002 fclose (fp2);
16003
16004 data.dictfile = dictfile1;
16005 data.dictfile2 = dictfile2;
16006
16007 if (words1_cnt >= words2_cnt)
16008 {
16009 data.combs_cnt = words2_cnt;
16010 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16011
16012 dictfiles = &data.dictfile;
16013
16014 dictcnt = 1;
16015 }
16016 else
16017 {
16018 data.combs_cnt = words1_cnt;
16019 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16020
16021 dictfiles = &data.dictfile2;
16022
16023 dictcnt = 1;
16024
16025 // we also have to switch wordlist related rules!
16026
16027 char *tmpc = data.rule_buf_l;
16028
16029 data.rule_buf_l = data.rule_buf_r;
16030 data.rule_buf_r = tmpc;
16031
16032 int tmpi = data.rule_len_l;
16033
16034 data.rule_len_l = data.rule_len_r;
16035 data.rule_len_r = tmpi;
16036 }
16037 }
16038 else if (attack_mode == ATTACK_MODE_BF)
16039 {
16040 char *mask = NULL;
16041
16042 maskcnt = 0;
16043
16044 if (benchmark == 0)
16045 {
16046 mask = myargv[optind + 1];
16047
16048 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16049
16050 if ((optind + 2) <= myargc)
16051 {
16052 struct stat file_stat;
16053
16054 if (stat (mask, &file_stat) == -1)
16055 {
16056 maskcnt = 1;
16057
16058 masks[maskcnt - 1] = mystrdup (mask);
16059 }
16060 else
16061 {
16062 int wls_left = myargc - (optind + 1);
16063
16064 uint masks_avail = INCR_MASKS;
16065
16066 for (int i = 0; i < wls_left; i++)
16067 {
16068 if (i != 0)
16069 {
16070 mask = myargv[optind + 1 + i];
16071
16072 if (stat (mask, &file_stat) == -1)
16073 {
16074 log_error ("ERROR: %s: %s", mask, strerror (errno));
16075
16076 return (-1);
16077 }
16078 }
16079
16080 uint is_file = S_ISREG (file_stat.st_mode);
16081
16082 if (is_file == 1)
16083 {
16084 FILE *mask_fp;
16085
16086 if ((mask_fp = fopen (mask, "r")) == NULL)
16087 {
16088 log_error ("ERROR: %s: %s", mask, strerror (errno));
16089
16090 return (-1);
16091 }
16092
16093 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16094
16095 while (!feof (mask_fp))
16096 {
16097 memset (line_buf, 0, HCBUFSIZ);
16098
16099 int line_len = fgetl (mask_fp, line_buf);
16100
16101 if (line_len == 0) continue;
16102
16103 if (line_buf[0] == '#') continue;
16104
16105 if (masks_avail == maskcnt)
16106 {
16107 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16108
16109 masks_avail += INCR_MASKS;
16110 }
16111
16112 masks[maskcnt] = mystrdup (line_buf);
16113
16114 maskcnt++;
16115 }
16116
16117 myfree (line_buf);
16118
16119 fclose (mask_fp);
16120 }
16121 else
16122 {
16123 log_error ("ERROR: %s: unsupported file-type", mask);
16124
16125 return (-1);
16126 }
16127 }
16128
16129 mask_from_file = 1;
16130 }
16131 }
16132 else
16133 {
16134 custom_charset_1 = (char *) "?l?d?u";
16135 custom_charset_2 = (char *) "?l?d";
16136 custom_charset_3 = (char *) "?l?d*!$@_";
16137
16138 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16139 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16140 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16141
16142 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16143
16144 wordlist_mode = WL_MODE_MASK;
16145
16146 data.wordlist_mode = wordlist_mode;
16147
16148 increment = 1;
16149
16150 maskcnt = 1;
16151 }
16152 }
16153 else
16154 {
16155 /**
16156 * generate full masks and charsets
16157 */
16158
16159 masks = (char **) mymalloc (sizeof (char *));
16160
16161 switch (hash_mode)
16162 {
16163 case 1731: pw_min = 5;
16164 pw_max = 5;
16165 mask = mystrdup ("?b?b?b?b?b");
16166 break;
16167 case 12500: pw_min = 5;
16168 pw_max = 5;
16169 mask = mystrdup ("?b?b?b?b?b");
16170 break;
16171 default: pw_min = 7;
16172 pw_max = 7;
16173 mask = mystrdup ("?b?b?b?b?b?b?b");
16174 break;
16175 }
16176
16177 maskcnt = 1;
16178
16179 masks[maskcnt - 1] = mystrdup (mask);
16180
16181 wordlist_mode = WL_MODE_MASK;
16182
16183 data.wordlist_mode = wordlist_mode;
16184
16185 increment = 1;
16186 }
16187
16188 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16189
16190 if (increment)
16191 {
16192 if (increment_min > pw_min) pw_min = increment_min;
16193
16194 if (increment_max < pw_max) pw_max = increment_max;
16195 }
16196 }
16197 else if (attack_mode == ATTACK_MODE_HYBRID1)
16198 {
16199 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16200
16201 // display
16202
16203 char *mask = myargv[myargc - 1];
16204
16205 maskcnt = 0;
16206
16207 masks = (char **) mymalloc (1 * sizeof (char *));
16208
16209 // mod
16210
16211 struct stat file_stat;
16212
16213 if (stat (mask, &file_stat) == -1)
16214 {
16215 maskcnt = 1;
16216
16217 masks[maskcnt - 1] = mystrdup (mask);
16218 }
16219 else
16220 {
16221 uint is_file = S_ISREG (file_stat.st_mode);
16222
16223 if (is_file == 1)
16224 {
16225 FILE *mask_fp;
16226
16227 if ((mask_fp = fopen (mask, "r")) == NULL)
16228 {
16229 log_error ("ERROR: %s: %s", mask, strerror (errno));
16230
16231 return (-1);
16232 }
16233
16234 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16235
16236 uint masks_avail = 1;
16237
16238 while (!feof (mask_fp))
16239 {
16240 memset (line_buf, 0, HCBUFSIZ);
16241
16242 int line_len = fgetl (mask_fp, line_buf);
16243
16244 if (line_len == 0) continue;
16245
16246 if (line_buf[0] == '#') continue;
16247
16248 if (masks_avail == maskcnt)
16249 {
16250 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16251
16252 masks_avail += INCR_MASKS;
16253 }
16254
16255 masks[maskcnt] = mystrdup (line_buf);
16256
16257 maskcnt++;
16258 }
16259
16260 myfree (line_buf);
16261
16262 fclose (mask_fp);
16263
16264 mask_from_file = 1;
16265 }
16266 else
16267 {
16268 maskcnt = 1;
16269
16270 masks[maskcnt - 1] = mystrdup (mask);
16271 }
16272 }
16273
16274 // base
16275
16276 int wls_left = myargc - (optind + 2);
16277
16278 for (int i = 0; i < wls_left; i++)
16279 {
16280 char *filename = myargv[optind + 1 + i];
16281
16282 struct stat file_stat;
16283
16284 if (stat (filename, &file_stat) == -1)
16285 {
16286 log_error ("ERROR: %s: %s", filename, strerror (errno));
16287
16288 return (-1);
16289 }
16290
16291 uint is_dir = S_ISDIR (file_stat.st_mode);
16292
16293 if (is_dir == 0)
16294 {
16295 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16296
16297 dictcnt++;
16298
16299 dictfiles[dictcnt - 1] = filename;
16300 }
16301 else
16302 {
16303 // do not allow --keyspace w/ a directory
16304
16305 if (keyspace == 1)
16306 {
16307 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16308
16309 return (-1);
16310 }
16311
16312 char **dictionary_files = NULL;
16313
16314 dictionary_files = scan_directory (filename);
16315
16316 if (dictionary_files != NULL)
16317 {
16318 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16319
16320 for (int d = 0; dictionary_files[d] != NULL; d++)
16321 {
16322 char *l1_filename = dictionary_files[d];
16323
16324 struct stat l1_stat;
16325
16326 if (stat (l1_filename, &l1_stat) == -1)
16327 {
16328 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16329
16330 return (-1);
16331 }
16332
16333 if (S_ISREG (l1_stat.st_mode))
16334 {
16335 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16336
16337 dictcnt++;
16338
16339 dictfiles[dictcnt - 1] = strdup (l1_filename);
16340 }
16341 }
16342 }
16343
16344 local_free (dictionary_files);
16345 }
16346 }
16347
16348 if (dictcnt < 1)
16349 {
16350 log_error ("ERROR: No usable dictionary file found.");
16351
16352 return (-1);
16353 }
16354
16355 if (increment)
16356 {
16357 maskcnt = 0;
16358
16359 uint mask_min = increment_min; // we can't reject smaller masks here
16360 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16361
16362 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16363 {
16364 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16365
16366 if (cur_mask == NULL) break;
16367
16368 masks[maskcnt] = cur_mask;
16369
16370 maskcnt++;
16371
16372 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16373 }
16374 }
16375 }
16376 else if (attack_mode == ATTACK_MODE_HYBRID2)
16377 {
16378 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16379
16380 // display
16381
16382 char *mask = myargv[optind + 1 + 0];
16383
16384 maskcnt = 0;
16385
16386 masks = (char **) mymalloc (1 * sizeof (char *));
16387
16388 // mod
16389
16390 struct stat file_stat;
16391
16392 if (stat (mask, &file_stat) == -1)
16393 {
16394 maskcnt = 1;
16395
16396 masks[maskcnt - 1] = mystrdup (mask);
16397 }
16398 else
16399 {
16400 uint is_file = S_ISREG (file_stat.st_mode);
16401
16402 if (is_file == 1)
16403 {
16404 FILE *mask_fp;
16405
16406 if ((mask_fp = fopen (mask, "r")) == NULL)
16407 {
16408 log_error ("ERROR: %s: %s", mask, strerror (errno));
16409
16410 return (-1);
16411 }
16412
16413 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16414
16415 uint masks_avail = 1;
16416
16417 while (!feof (mask_fp))
16418 {
16419 memset (line_buf, 0, HCBUFSIZ);
16420
16421 int line_len = fgetl (mask_fp, line_buf);
16422
16423 if (line_len == 0) continue;
16424
16425 if (line_buf[0] == '#') continue;
16426
16427 if (masks_avail == maskcnt)
16428 {
16429 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16430
16431 masks_avail += INCR_MASKS;
16432 }
16433
16434 masks[maskcnt] = mystrdup (line_buf);
16435
16436 maskcnt++;
16437 }
16438
16439 myfree (line_buf);
16440
16441 fclose (mask_fp);
16442
16443 mask_from_file = 1;
16444 }
16445 else
16446 {
16447 maskcnt = 1;
16448
16449 masks[maskcnt - 1] = mystrdup (mask);
16450 }
16451 }
16452
16453 // base
16454
16455 int wls_left = myargc - (optind + 2);
16456
16457 for (int i = 0; i < wls_left; i++)
16458 {
16459 char *filename = myargv[optind + 2 + i];
16460
16461 struct stat file_stat;
16462
16463 if (stat (filename, &file_stat) == -1)
16464 {
16465 log_error ("ERROR: %s: %s", filename, strerror (errno));
16466
16467 return (-1);
16468 }
16469
16470 uint is_dir = S_ISDIR (file_stat.st_mode);
16471
16472 if (is_dir == 0)
16473 {
16474 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16475
16476 dictcnt++;
16477
16478 dictfiles[dictcnt - 1] = filename;
16479 }
16480 else
16481 {
16482 // do not allow --keyspace w/ a directory
16483
16484 if (keyspace == 1)
16485 {
16486 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16487
16488 return (-1);
16489 }
16490
16491 char **dictionary_files = NULL;
16492
16493 dictionary_files = scan_directory (filename);
16494
16495 if (dictionary_files != NULL)
16496 {
16497 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16498
16499 for (int d = 0; dictionary_files[d] != NULL; d++)
16500 {
16501 char *l1_filename = dictionary_files[d];
16502
16503 struct stat l1_stat;
16504
16505 if (stat (l1_filename, &l1_stat) == -1)
16506 {
16507 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16508
16509 return (-1);
16510 }
16511
16512 if (S_ISREG (l1_stat.st_mode))
16513 {
16514 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16515
16516 dictcnt++;
16517
16518 dictfiles[dictcnt - 1] = strdup (l1_filename);
16519 }
16520 }
16521 }
16522
16523 local_free (dictionary_files);
16524 }
16525 }
16526
16527 if (dictcnt < 1)
16528 {
16529 log_error ("ERROR: No usable dictionary file found.");
16530
16531 return (-1);
16532 }
16533
16534 if (increment)
16535 {
16536 maskcnt = 0;
16537
16538 uint mask_min = increment_min; // we can't reject smaller masks here
16539 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16540
16541 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16542 {
16543 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16544
16545 if (cur_mask == NULL) break;
16546
16547 masks[maskcnt] = cur_mask;
16548
16549 maskcnt++;
16550
16551 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16552 }
16553 }
16554 }
16555
16556 data.pw_min = pw_min;
16557 data.pw_max = pw_max;
16558
16559 /**
16560 * weak hash check
16561 */
16562
16563 if (weak_hash_threshold >= salts_cnt)
16564 {
16565 hc_device_param_t *device_param = NULL;
16566
16567 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16568 {
16569 device_param = &data.devices_param[device_id];
16570
16571 if (device_param->skipped) continue;
16572
16573 break;
16574 }
16575
16576 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16577
16578 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16579 {
16580 weak_hash_check (device_param, salt_pos);
16581 }
16582
16583 // Display hack, guarantee that there is at least one \r before real start
16584
16585 //if (data.quiet == 0) log_info ("");
16586 }
16587
16588 /**
16589 * status and monitor threads
16590 */
16591
16592 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16593
16594 hc_thread_t i_thread = 0;
16595
16596 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16597 {
16598 hc_thread_create (i_thread, thread_keypress, &benchmark);
16599 }
16600
16601 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16602
16603 uint ni_threads_cnt = 0;
16604
16605 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16606
16607 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16608
16609 ni_threads_cnt++;
16610
16611 /**
16612 * Outfile remove
16613 */
16614
16615 if (keyspace == 0)
16616 {
16617 if (outfile_check_timer != 0)
16618 {
16619 if (data.outfile_check_directory != NULL)
16620 {
16621 if ((hash_mode != 5200) &&
16622 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16623 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16624 (hash_mode != 9000))
16625 {
16626 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16627
16628 ni_threads_cnt++;
16629 }
16630 else
16631 {
16632 outfile_check_timer = 0;
16633 }
16634 }
16635 else
16636 {
16637 outfile_check_timer = 0;
16638 }
16639 }
16640 }
16641
16642 /**
16643 * Inform the user if we got some hashes remove because of the pot file remove feature
16644 */
16645
16646 if (data.quiet == 0)
16647 {
16648 if (potfile_remove_cracks > 0)
16649 {
16650 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16651 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16652 }
16653 }
16654
16655 data.outfile_check_timer = outfile_check_timer;
16656
16657 /**
16658 * main loop
16659 */
16660
16661 char **induction_dictionaries = NULL;
16662
16663 int induction_dictionaries_cnt = 0;
16664
16665 hcstat_table_t *root_table_buf = NULL;
16666 hcstat_table_t *markov_table_buf = NULL;
16667
16668 uint initial_restore_done = 0;
16669
16670 data.maskcnt = maskcnt;
16671
16672 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16673 {
16674 if (data.devices_status == STATUS_CRACKED) break;
16675
16676 data.devices_status = STATUS_INIT;
16677
16678 if (maskpos > rd->maskpos)
16679 {
16680 rd->dictpos = 0;
16681 }
16682
16683 rd->maskpos = maskpos;
16684 data.maskpos = maskpos;
16685
16686 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16687 {
16688 char *mask = masks[maskpos];
16689
16690 if (mask_from_file == 1)
16691 {
16692 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16693
16694 char *str_ptr;
16695 uint str_pos;
16696
16697 uint mask_offset = 0;
16698
16699 uint separator_cnt;
16700
16701 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16702 {
16703 str_ptr = strstr (mask + mask_offset, ",");
16704
16705 if (str_ptr == NULL) break;
16706
16707 str_pos = str_ptr - mask;
16708
16709 // escaped separator, i.e. "\,"
16710
16711 if (str_pos > 0)
16712 {
16713 if (mask[str_pos - 1] == '\\')
16714 {
16715 separator_cnt --;
16716
16717 mask_offset = str_pos + 1;
16718
16719 continue;
16720 }
16721 }
16722
16723 // reset the offset
16724
16725 mask_offset = 0;
16726
16727 mask[str_pos] = '\0';
16728
16729 switch (separator_cnt)
16730 {
16731 case 0:
16732 mp_reset_usr (mp_usr, 0);
16733
16734 custom_charset_1 = mask;
16735 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16736 break;
16737
16738 case 1:
16739 mp_reset_usr (mp_usr, 1);
16740
16741 custom_charset_2 = mask;
16742 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16743 break;
16744
16745 case 2:
16746 mp_reset_usr (mp_usr, 2);
16747
16748 custom_charset_3 = mask;
16749 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16750 break;
16751
16752 case 3:
16753 mp_reset_usr (mp_usr, 3);
16754
16755 custom_charset_4 = mask;
16756 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16757 break;
16758 }
16759
16760 mask = mask + str_pos + 1;
16761 }
16762 }
16763
16764 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16765 {
16766 if (maskpos > 0)
16767 {
16768 local_free (css_buf);
16769 local_free (data.root_css_buf);
16770 local_free (data.markov_css_buf);
16771
16772 local_free (masks[maskpos - 1]);
16773 }
16774
16775 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16776
16777 data.mask = mask;
16778 data.css_cnt = css_cnt;
16779 data.css_buf = css_buf;
16780
16781 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16782
16783 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16784
16785 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16786 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16787
16788 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16789
16790 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16791
16792 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16793 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16794
16795 data.root_css_buf = root_css_buf;
16796 data.markov_css_buf = markov_css_buf;
16797
16798 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16799
16800 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16801
16802 local_free (root_table_buf);
16803 local_free (markov_table_buf);
16804
16805 // args
16806
16807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16808 {
16809 hc_device_param_t *device_param = &data.devices_param[device_id];
16810
16811 if (device_param->skipped) continue;
16812
16813 device_param->kernel_params_mp[0] = &device_param->d_combs;
16814 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16815 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16816
16817 device_param->kernel_params_mp_buf64[3] = 0;
16818 device_param->kernel_params_mp_buf32[4] = css_cnt;
16819 device_param->kernel_params_mp_buf32[5] = 0;
16820 device_param->kernel_params_mp_buf32[6] = 0;
16821 device_param->kernel_params_mp_buf32[7] = 0;
16822
16823 if (attack_mode == ATTACK_MODE_HYBRID1)
16824 {
16825 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16826 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16827 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16828 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16829 }
16830 else if (attack_mode == ATTACK_MODE_HYBRID2)
16831 {
16832 device_param->kernel_params_mp_buf32[5] = 0;
16833 device_param->kernel_params_mp_buf32[6] = 0;
16834 device_param->kernel_params_mp_buf32[7] = 0;
16835 }
16836
16837 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]);
16838 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]);
16839 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]);
16840
16841 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);
16842 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);
16843 }
16844 }
16845 else if (attack_mode == ATTACK_MODE_BF)
16846 {
16847 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16848
16849 if (increment)
16850 {
16851 for (uint i = 0; i < dictcnt; i++)
16852 {
16853 local_free (dictfiles[i]);
16854 }
16855
16856 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16857 {
16858 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16859
16860 if (l1_filename == NULL) break;
16861
16862 dictcnt++;
16863
16864 dictfiles[dictcnt - 1] = l1_filename;
16865 }
16866 }
16867 else
16868 {
16869 dictcnt++;
16870
16871 dictfiles[dictcnt - 1] = mask;
16872 }
16873
16874 if (dictcnt == 0)
16875 {
16876 log_error ("ERROR: Mask is too small");
16877
16878 return (-1);
16879 }
16880 }
16881 }
16882
16883 free (induction_dictionaries);
16884
16885 // induction_dictionaries_cnt = 0; // implied
16886
16887 if (attack_mode != ATTACK_MODE_BF)
16888 {
16889 if (keyspace == 0)
16890 {
16891 induction_dictionaries = scan_directory (induction_directory);
16892
16893 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16894 }
16895 }
16896
16897 if (induction_dictionaries_cnt)
16898 {
16899 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16900 }
16901
16902 /**
16903 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16904 */
16905 if (keyspace == 1)
16906 {
16907 if ((maskcnt > 1) || (dictcnt > 1))
16908 {
16909 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16910
16911 return (-1);
16912 }
16913 }
16914
16915 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16916 {
16917 char *subid = logfile_generate_subid ();
16918
16919 data.subid = subid;
16920
16921 logfile_sub_msg ("START");
16922
16923 data.devices_status = STATUS_INIT;
16924
16925 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16926 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16927 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16928
16929 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16930
16931 data.cpt_pos = 0;
16932
16933 data.cpt_start = time (NULL);
16934
16935 data.cpt_total = 0;
16936
16937 if (data.restore == 0)
16938 {
16939 rd->words_cur = skip;
16940
16941 skip = 0;
16942
16943 data.skip = 0;
16944 }
16945
16946 data.ms_paused = 0;
16947
16948 data.words_cur = rd->words_cur;
16949
16950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16951 {
16952 hc_device_param_t *device_param = &data.devices_param[device_id];
16953
16954 if (device_param->skipped) continue;
16955
16956 device_param->speed_pos = 0;
16957
16958 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16959 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16960
16961 device_param->exec_pos = 0;
16962
16963 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16964
16965 device_param->kernel_power = device_param->kernel_power_user;
16966
16967 device_param->outerloop_pos = 0;
16968 device_param->outerloop_left = 0;
16969 device_param->innerloop_pos = 0;
16970 device_param->innerloop_left = 0;
16971
16972 // some more resets:
16973
16974 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16975
16976 device_param->pws_cnt = 0;
16977
16978 device_param->words_off = 0;
16979 device_param->words_done = 0;
16980 }
16981
16982 data.kernel_power_div = 0;
16983
16984 // figure out some workload
16985
16986 if (attack_mode == ATTACK_MODE_STRAIGHT)
16987 {
16988 if (data.wordlist_mode == WL_MODE_FILE)
16989 {
16990 char *dictfile = NULL;
16991
16992 if (induction_dictionaries_cnt)
16993 {
16994 dictfile = induction_dictionaries[0];
16995 }
16996 else
16997 {
16998 dictfile = dictfiles[dictpos];
16999 }
17000
17001 data.dictfile = dictfile;
17002
17003 logfile_sub_string (dictfile);
17004
17005 for (uint i = 0; i < rp_files_cnt; i++)
17006 {
17007 logfile_sub_var_string ("rulefile", rp_files[i]);
17008 }
17009
17010 FILE *fd2 = fopen (dictfile, "rb");
17011
17012 if (fd2 == NULL)
17013 {
17014 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17015
17016 return (-1);
17017 }
17018
17019 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17020
17021 fclose (fd2);
17022
17023 if (data.words_cnt == 0)
17024 {
17025 if (data.devices_status == STATUS_CRACKED) break;
17026 if (data.devices_status == STATUS_ABORTED) break;
17027
17028 dictpos++;
17029
17030 continue;
17031 }
17032 }
17033 }
17034 else if (attack_mode == ATTACK_MODE_COMBI)
17035 {
17036 char *dictfile = data.dictfile;
17037 char *dictfile2 = data.dictfile2;
17038
17039 logfile_sub_string (dictfile);
17040 logfile_sub_string (dictfile2);
17041
17042 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17043 {
17044 FILE *fd2 = fopen (dictfile, "rb");
17045
17046 if (fd2 == NULL)
17047 {
17048 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17049
17050 return (-1);
17051 }
17052
17053 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17054
17055 fclose (fd2);
17056 }
17057 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17058 {
17059 FILE *fd2 = fopen (dictfile2, "rb");
17060
17061 if (fd2 == NULL)
17062 {
17063 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17064
17065 return (-1);
17066 }
17067
17068 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17069
17070 fclose (fd2);
17071 }
17072
17073 if (data.words_cnt == 0)
17074 {
17075 if (data.devices_status == STATUS_CRACKED) break;
17076 if (data.devices_status == STATUS_ABORTED) break;
17077
17078 dictpos++;
17079
17080 continue;
17081 }
17082 }
17083 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17084 {
17085 char *dictfile = NULL;
17086
17087 if (induction_dictionaries_cnt)
17088 {
17089 dictfile = induction_dictionaries[0];
17090 }
17091 else
17092 {
17093 dictfile = dictfiles[dictpos];
17094 }
17095
17096 data.dictfile = dictfile;
17097
17098 char *mask = data.mask;
17099
17100 logfile_sub_string (dictfile);
17101 logfile_sub_string (mask);
17102
17103 FILE *fd2 = fopen (dictfile, "rb");
17104
17105 if (fd2 == NULL)
17106 {
17107 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17108
17109 return (-1);
17110 }
17111
17112 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17113
17114 fclose (fd2);
17115
17116 if (data.words_cnt == 0)
17117 {
17118 if (data.devices_status == STATUS_CRACKED) break;
17119 if (data.devices_status == STATUS_ABORTED) break;
17120
17121 dictpos++;
17122
17123 continue;
17124 }
17125 }
17126 else if (attack_mode == ATTACK_MODE_BF)
17127 {
17128 local_free (css_buf);
17129 local_free (data.root_css_buf);
17130 local_free (data.markov_css_buf);
17131
17132 char *mask = dictfiles[dictpos];
17133
17134 logfile_sub_string (mask);
17135
17136 // base
17137
17138 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17139
17140 if (opts_type & OPTS_TYPE_PT_UNICODE)
17141 {
17142 uint css_cnt_unicode = css_cnt * 2;
17143
17144 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17145
17146 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17147 {
17148 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17149
17150 css_buf_unicode[j + 1].cs_buf[0] = 0;
17151 css_buf_unicode[j + 1].cs_len = 1;
17152 }
17153
17154 free (css_buf);
17155
17156 css_buf = css_buf_unicode;
17157 css_cnt = css_cnt_unicode;
17158 }
17159
17160 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17161
17162 uint mask_min = pw_min;
17163 uint mask_max = pw_max;
17164
17165 if (opts_type & OPTS_TYPE_PT_UNICODE)
17166 {
17167 mask_min *= 2;
17168 mask_max *= 2;
17169 }
17170
17171 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17172 {
17173 if (css_cnt < mask_min)
17174 {
17175 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17176 }
17177
17178 if (css_cnt > mask_max)
17179 {
17180 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17181 }
17182
17183 // skip to next mask
17184
17185 dictpos++;
17186
17187 rd->dictpos = dictpos;
17188
17189 logfile_sub_msg ("STOP");
17190
17191 continue;
17192 }
17193
17194 uint save_css_cnt = css_cnt;
17195
17196 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17197 {
17198 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17199 {
17200 uint salt_len = (uint) data.salts_buf[0].salt_len;
17201 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17202
17203 uint css_cnt_salt = css_cnt + salt_len;
17204
17205 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17206
17207 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17208
17209 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17210 {
17211 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17212 css_buf_salt[j].cs_len = 1;
17213 }
17214
17215 free (css_buf);
17216
17217 css_buf = css_buf_salt;
17218 css_cnt = css_cnt_salt;
17219 }
17220 }
17221
17222 data.mask = mask;
17223 data.css_cnt = css_cnt;
17224 data.css_buf = css_buf;
17225
17226 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17227
17228 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17229
17230 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17231
17232 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17233 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17234
17235 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17236
17237 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17238
17239 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17240 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17241
17242 data.root_css_buf = root_css_buf;
17243 data.markov_css_buf = markov_css_buf;
17244
17245 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17246
17247 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17248
17249 local_free (root_table_buf);
17250 local_free (markov_table_buf);
17251
17252 // copy + args
17253
17254 uint css_cnt_l = css_cnt;
17255 uint css_cnt_r;
17256
17257 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17258 {
17259 if (save_css_cnt < 6)
17260 {
17261 css_cnt_r = 1;
17262 }
17263 else if (save_css_cnt == 6)
17264 {
17265 css_cnt_r = 2;
17266 }
17267 else
17268 {
17269 if (opts_type & OPTS_TYPE_PT_UNICODE)
17270 {
17271 if (save_css_cnt == 8 || save_css_cnt == 10)
17272 {
17273 css_cnt_r = 2;
17274 }
17275 else
17276 {
17277 css_cnt_r = 4;
17278 }
17279 }
17280 else
17281 {
17282 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17283 {
17284 css_cnt_r = 3;
17285 }
17286 else
17287 {
17288 css_cnt_r = 4;
17289 }
17290 }
17291 }
17292 }
17293 else
17294 {
17295 css_cnt_r = 1;
17296
17297 /* unfinished code?
17298 int sum = css_buf[css_cnt_r - 1].cs_len;
17299
17300 for (uint i = 1; i < 4 && i < css_cnt; i++)
17301 {
17302 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17303
17304 css_cnt_r++;
17305
17306 sum *= css_buf[css_cnt_r - 1].cs_len;
17307 }
17308 */
17309 }
17310
17311 css_cnt_l -= css_cnt_r;
17312
17313 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17314
17315 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17316 {
17317 hc_device_param_t *device_param = &data.devices_param[device_id];
17318
17319 if (device_param->skipped) continue;
17320
17321 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17322 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17323 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17324
17325 device_param->kernel_params_mp_l_buf64[3] = 0;
17326 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17327 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17328 device_param->kernel_params_mp_l_buf32[6] = 0;
17329 device_param->kernel_params_mp_l_buf32[7] = 0;
17330 device_param->kernel_params_mp_l_buf32[8] = 0;
17331
17332 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17333 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17334 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17335 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17336
17337 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17338 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17339 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17340
17341 device_param->kernel_params_mp_r_buf64[3] = 0;
17342 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17343 device_param->kernel_params_mp_r_buf32[5] = 0;
17344 device_param->kernel_params_mp_r_buf32[6] = 0;
17345 device_param->kernel_params_mp_r_buf32[7] = 0;
17346
17347 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]);
17348 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]);
17349 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]);
17350
17351 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]);
17352 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]);
17353 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]);
17354
17355 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);
17356 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);
17357 }
17358 }
17359
17360 u64 words_base = data.words_cnt;
17361
17362 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17363 {
17364 if (data.kernel_rules_cnt)
17365 {
17366 words_base /= data.kernel_rules_cnt;
17367 }
17368 }
17369 else if (data.attack_kern == ATTACK_KERN_COMBI)
17370 {
17371 if (data.combs_cnt)
17372 {
17373 words_base /= data.combs_cnt;
17374 }
17375 }
17376 else if (data.attack_kern == ATTACK_KERN_BF)
17377 {
17378 if (data.bfs_cnt)
17379 {
17380 words_base /= data.bfs_cnt;
17381 }
17382 }
17383
17384 data.words_base = words_base;
17385
17386 if (keyspace == 1)
17387 {
17388 log_info ("%llu", (unsigned long long int) words_base);
17389
17390 return (0);
17391 }
17392
17393 if (data.words_cur > data.words_base)
17394 {
17395 log_error ("ERROR: restore value greater keyspace");
17396
17397 return (-1);
17398 }
17399
17400 if (data.words_cur)
17401 {
17402 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17403 {
17404 for (uint i = 0; i < data.salts_cnt; i++)
17405 {
17406 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17407 }
17408 }
17409 else if (data.attack_kern == ATTACK_KERN_COMBI)
17410 {
17411 for (uint i = 0; i < data.salts_cnt; i++)
17412 {
17413 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17414 }
17415 }
17416 else if (data.attack_kern == ATTACK_KERN_BF)
17417 {
17418 for (uint i = 0; i < data.salts_cnt; i++)
17419 {
17420 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17421 }
17422 }
17423 }
17424
17425 /*
17426 * Inform user about possible slow speeds
17427 */
17428
17429 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17430 {
17431 if (data.words_base < kernel_power_all)
17432 {
17433 if (quiet == 0)
17434 {
17435 log_info ("ATTENTION!");
17436 log_info (" The wordlist or mask you are using is too small.");
17437 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17438 log_info (" The cracking speed will drop.");
17439 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17440 log_info ("");
17441 }
17442 }
17443 }
17444
17445 /*
17446 * Update loopback file
17447 */
17448
17449 if (loopback == 1)
17450 {
17451 time_t now;
17452
17453 time (&now);
17454
17455 uint random_num = get_random_num (0, 9999);
17456
17457 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17458
17459 data.loopback_file = loopback_file;
17460 }
17461
17462 /*
17463 * Update dictionary statistic
17464 */
17465
17466 if (keyspace == 0)
17467 {
17468 dictstat_fp = fopen (dictstat, "wb");
17469
17470 if (dictstat_fp)
17471 {
17472 lock_file (dictstat_fp);
17473
17474 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17475
17476 fclose (dictstat_fp);
17477 }
17478 }
17479
17480 data.devices_status = STATUS_RUNNING;
17481
17482 if (initial_restore_done == 0)
17483 {
17484 if (data.restore_disable == 0) cycle_restore ();
17485
17486 initial_restore_done = 1;
17487 }
17488
17489 hc_timer_set (&data.timer_running);
17490
17491 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17492 {
17493 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17494 {
17495 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17496 if (quiet == 0) fflush (stdout);
17497 }
17498 }
17499 else if (wordlist_mode == WL_MODE_STDIN)
17500 {
17501 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17502 if (data.quiet == 0) log_info ("");
17503 }
17504
17505 time_t runtime_start;
17506
17507 time (&runtime_start);
17508
17509 data.runtime_start = runtime_start;
17510
17511 /**
17512 * create cracker threads
17513 */
17514
17515 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17516
17517 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17518 {
17519 hc_device_param_t *device_param = &devices_param[device_id];
17520
17521 if (wordlist_mode == WL_MODE_STDIN)
17522 {
17523 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17524 }
17525 else
17526 {
17527 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17528 }
17529 }
17530
17531 // wait for crack threads to exit
17532
17533 hc_thread_wait (data.devices_cnt, c_threads);
17534
17535 local_free (c_threads);
17536
17537 data.restore = 0;
17538
17539 // finalize task
17540
17541 logfile_sub_var_uint ("status-after-work", data.devices_status);
17542
17543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17544
17545 if (data.devices_status == STATUS_CRACKED) break;
17546 if (data.devices_status == STATUS_ABORTED) break;
17547
17548 if (data.devices_status == STATUS_BYPASS)
17549 {
17550 data.devices_status = STATUS_RUNNING;
17551 }
17552
17553 if (induction_dictionaries_cnt)
17554 {
17555 unlink (induction_dictionaries[0]);
17556 }
17557
17558 free (induction_dictionaries);
17559
17560 if (attack_mode != ATTACK_MODE_BF)
17561 {
17562 induction_dictionaries = scan_directory (induction_directory);
17563
17564 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17565 }
17566
17567 if (benchmark == 0)
17568 {
17569 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17570 {
17571 if (quiet == 0) clear_prompt ();
17572
17573 if (quiet == 0) log_info ("");
17574
17575 if (status == 1)
17576 {
17577 status_display ();
17578 }
17579 else
17580 {
17581 if (quiet == 0) status_display ();
17582 }
17583
17584 if (quiet == 0) log_info ("");
17585 }
17586 }
17587
17588 if (attack_mode == ATTACK_MODE_BF)
17589 {
17590 dictpos++;
17591
17592 rd->dictpos = dictpos;
17593 }
17594 else
17595 {
17596 if (induction_dictionaries_cnt)
17597 {
17598 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17599 }
17600 else
17601 {
17602 dictpos++;
17603
17604 rd->dictpos = dictpos;
17605 }
17606 }
17607
17608 time_t runtime_stop;
17609
17610 time (&runtime_stop);
17611
17612 data.runtime_stop = runtime_stop;
17613
17614 logfile_sub_uint (runtime_start);
17615 logfile_sub_uint (runtime_stop);
17616
17617 logfile_sub_msg ("STOP");
17618
17619 global_free (subid);
17620 }
17621
17622 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17623
17624 if (data.devices_status == STATUS_CRACKED) break;
17625 if (data.devices_status == STATUS_ABORTED) break;
17626 if (data.devices_status == STATUS_QUIT) break;
17627
17628 if (data.devices_status == STATUS_BYPASS)
17629 {
17630 data.devices_status = STATUS_RUNNING;
17631 }
17632 }
17633
17634 // 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
17635
17636 if (attack_mode == ATTACK_MODE_STRAIGHT)
17637 {
17638 if (data.wordlist_mode == WL_MODE_FILE)
17639 {
17640 if (data.dictfile == NULL)
17641 {
17642 if (dictfiles != NULL)
17643 {
17644 data.dictfile = dictfiles[0];
17645
17646 hc_timer_set (&data.timer_running);
17647 }
17648 }
17649 }
17650 }
17651 // NOTE: combi is okay because it is already set beforehand
17652 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17653 {
17654 if (data.dictfile == NULL)
17655 {
17656 if (dictfiles != NULL)
17657 {
17658 hc_timer_set (&data.timer_running);
17659
17660 data.dictfile = dictfiles[0];
17661 }
17662 }
17663 }
17664 else if (attack_mode == ATTACK_MODE_BF)
17665 {
17666 if (data.mask == NULL)
17667 {
17668 hc_timer_set (&data.timer_running);
17669
17670 data.mask = masks[0];
17671 }
17672 }
17673
17674 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17675 {
17676 data.devices_status = STATUS_EXHAUSTED;
17677 }
17678
17679 // if cracked / aborted remove last induction dictionary
17680
17681 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17682 {
17683 struct stat induct_stat;
17684
17685 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17686 {
17687 unlink (induction_dictionaries[file_pos]);
17688 }
17689 }
17690
17691 // wait for non-interactive threads
17692
17693 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17694 {
17695 hc_thread_wait (1, &ni_threads[thread_idx]);
17696 }
17697
17698 local_free (ni_threads);
17699
17700 // wait for interactive threads
17701
17702 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17703 {
17704 hc_thread_wait (1, &i_thread);
17705 }
17706
17707 // we dont need restore file anymore
17708 if (data.restore_disable == 0)
17709 {
17710 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17711 {
17712 unlink (eff_restore_file);
17713 unlink (new_restore_file);
17714 }
17715 else
17716 {
17717 cycle_restore ();
17718 }
17719 }
17720
17721 // finally save left hashes
17722
17723 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17724 {
17725 save_hash ();
17726 }
17727
17728 /**
17729 * Clean up
17730 */
17731
17732 if (benchmark == 1)
17733 {
17734 status_benchmark ();
17735
17736 if (status_automat == 0)
17737 {
17738 log_info ("");
17739 }
17740 }
17741 else
17742 {
17743 if (quiet == 0) clear_prompt ();
17744
17745 if (quiet == 0) log_info ("");
17746
17747 if (status == 1)
17748 {
17749 status_display ();
17750 }
17751 else
17752 {
17753 if (quiet == 0) status_display ();
17754 }
17755
17756 if (quiet == 0) log_info ("");
17757 }
17758
17759 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17760 {
17761 hc_device_param_t *device_param = &data.devices_param[device_id];
17762
17763 if (device_param->skipped) continue;
17764
17765 local_free (device_param->combs_buf);
17766
17767 local_free (device_param->hooks_buf);
17768
17769 local_free (device_param->device_name);
17770
17771 local_free (device_param->device_name_chksum);
17772
17773 local_free (device_param->device_version);
17774
17775 local_free (device_param->driver_version);
17776
17777 if (device_param->pws_buf) myfree (device_param->pws_buf);
17778 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17779 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17780 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17781 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17782 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17783 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17784 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17785 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17786 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17787 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17788 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17789 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17790 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17791 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17792 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17793 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17794 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17795 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17796 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17797 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17798 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17799 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17800 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17801 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17802 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17803 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17804 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17805 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17806
17807 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17808 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17809 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17810 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17811 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17812 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17813 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17814 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17815 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17816 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17817
17818 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17819 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17820 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17821
17822 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17823 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17824 }
17825
17826 // reset default fan speed
17827
17828 #ifdef HAVE_HWMON
17829 if (gpu_temp_disable == 0)
17830 {
17831 #ifdef HAVE_ADL
17832 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17833 {
17834 hc_thread_mutex_lock (mux_adl);
17835
17836 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17837 {
17838 hc_device_param_t *device_param = &data.devices_param[device_id];
17839
17840 if (device_param->skipped) continue;
17841
17842 if (data.hm_device[device_id].fan_supported == 1)
17843 {
17844 int fanspeed = temp_retain_fanspeed_value[device_id];
17845
17846 if (fanspeed == -1) continue;
17847
17848 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17849
17850 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17851 }
17852 }
17853
17854 hc_thread_mutex_unlock (mux_adl);
17855 }
17856 #endif // HAVE_ADL
17857 }
17858
17859 #ifdef HAVE_ADL
17860 // reset power tuning
17861
17862 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17863 {
17864 hc_thread_mutex_lock (mux_adl);
17865
17866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17867 {
17868 hc_device_param_t *device_param = &data.devices_param[device_id];
17869
17870 if (device_param->skipped) continue;
17871
17872 if (data.hm_device[device_id].od_version == 6)
17873 {
17874 // check powertune capabilities first, if not available then skip device
17875
17876 int powertune_supported = 0;
17877
17878 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17879 {
17880 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17881
17882 return (-1);
17883 }
17884
17885 if (powertune_supported != 0)
17886 {
17887 // powercontrol settings
17888
17889 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17890 {
17891 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17892
17893 return (-1);
17894 }
17895
17896 // clocks
17897
17898 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17899
17900 performance_state->iNumberOfPerformanceLevels = 2;
17901
17902 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17903 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17904 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17905 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17906
17907 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17908 {
17909 log_info ("ERROR: Failed to restore ADL performance state");
17910
17911 return (-1);
17912 }
17913
17914 local_free (performance_state);
17915 }
17916 }
17917 }
17918
17919 hc_thread_mutex_unlock (mux_adl);
17920 }
17921 #endif // HAVE_ADL
17922
17923 if (gpu_temp_disable == 0)
17924 {
17925 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17926 if (data.hm_nv)
17927 {
17928 #if defined(LINUX) && defined(HAVE_NVML)
17929
17930 hm_NVML_nvmlShutdown (data.hm_nv);
17931
17932 nvml_close (data.hm_nv);
17933
17934 #elif defined(WIN) && (HAVE_NVAPI)
17935
17936 hm_NvAPI_Unload (data.hm_nv);
17937
17938 nvapi_close (data.hm_nv);
17939
17940 #endif
17941
17942 data.hm_nv = NULL;
17943 }
17944 #endif
17945
17946 #ifdef HAVE_ADL
17947 if (data.hm_amd)
17948 {
17949 hm_ADL_Main_Control_Destroy (data.hm_amd);
17950
17951 adl_close (data.hm_amd);
17952 data.hm_amd = NULL;
17953 }
17954 #endif
17955 }
17956 #endif // HAVE_HWMON
17957
17958 // free memory
17959
17960 local_free (masks);
17961
17962 local_free (dictstat_base);
17963
17964 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17965 {
17966 pot_t *pot_ptr = &pot[pot_pos];
17967
17968 hash_t *hash = &pot_ptr->hash;
17969
17970 local_free (hash->digest);
17971
17972 if (isSalted)
17973 {
17974 local_free (hash->salt);
17975 }
17976 }
17977
17978 local_free (pot);
17979
17980 local_free (all_kernel_rules_cnt);
17981 local_free (all_kernel_rules_buf);
17982
17983 local_free (wl_data->buf);
17984 local_free (wl_data);
17985
17986 local_free (bitmap_s1_a);
17987 local_free (bitmap_s1_b);
17988 local_free (bitmap_s1_c);
17989 local_free (bitmap_s1_d);
17990 local_free (bitmap_s2_a);
17991 local_free (bitmap_s2_b);
17992 local_free (bitmap_s2_c);
17993 local_free (bitmap_s2_d);
17994
17995 #ifdef HAVE_HWMON
17996 local_free (temp_retain_fanspeed_value);
17997 #ifdef HAVE_ADL
17998 local_free (od_clock_mem_status);
17999 local_free (od_power_control_status);
18000 #endif // ADL
18001 #endif
18002
18003 global_free (devices_param);
18004
18005 global_free (kernel_rules_buf);
18006
18007 global_free (root_css_buf);
18008 global_free (markov_css_buf);
18009
18010 global_free (digests_buf);
18011 global_free (digests_shown);
18012 global_free (digests_shown_tmp);
18013
18014 global_free (salts_buf);
18015 global_free (salts_shown);
18016
18017 global_free (esalts_buf);
18018
18019 global_free (words_progress_done);
18020 global_free (words_progress_rejected);
18021 global_free (words_progress_restored);
18022
18023 if (pot_fp) fclose (pot_fp);
18024
18025 if (data.devices_status == STATUS_QUIT) break;
18026 }
18027
18028 // destroy others mutex
18029
18030 hc_thread_mutex_delete (mux_dispatcher);
18031 hc_thread_mutex_delete (mux_counter);
18032 hc_thread_mutex_delete (mux_display);
18033 hc_thread_mutex_delete (mux_adl);
18034
18035 // free memory
18036
18037 local_free (eff_restore_file);
18038 local_free (new_restore_file);
18039
18040 local_free (rd);
18041
18042 // tuning db
18043
18044 tuning_db_destroy (tuning_db);
18045
18046 // loopback
18047
18048 local_free (loopback_file);
18049
18050 if (loopback == 1) unlink (loopback_file);
18051
18052 // induction directory
18053
18054 if (induction_dir == NULL)
18055 {
18056 if (attack_mode != ATTACK_MODE_BF)
18057 {
18058 if (rmdir (induction_directory) == -1)
18059 {
18060 if (errno == ENOENT)
18061 {
18062 // good, we can ignore
18063 }
18064 else if (errno == ENOTEMPTY)
18065 {
18066 // good, we can ignore
18067 }
18068 else
18069 {
18070 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18071
18072 return (-1);
18073 }
18074 }
18075
18076 local_free (induction_directory);
18077 }
18078 }
18079
18080 // outfile-check directory
18081
18082 if (outfile_check_dir == NULL)
18083 {
18084 if (rmdir (outfile_check_directory) == -1)
18085 {
18086 if (errno == ENOENT)
18087 {
18088 // good, we can ignore
18089 }
18090 else if (errno == ENOTEMPTY)
18091 {
18092 // good, we can ignore
18093 }
18094 else
18095 {
18096 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18097
18098 return (-1);
18099 }
18100 }
18101
18102 local_free (outfile_check_directory);
18103 }
18104
18105 time_t proc_stop;
18106
18107 time (&proc_stop);
18108
18109 logfile_top_uint (proc_start);
18110 logfile_top_uint (proc_stop);
18111
18112 logfile_top_msg ("STOP");
18113
18114 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18115 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18116
18117 if (data.ocl) ocl_close (data.ocl);
18118
18119 if (data.devices_status == STATUS_ABORTED) return 2;
18120 if (data.devices_status == STATUS_QUIT) return 2;
18121 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18122 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18123 if (data.devices_status == STATUS_CRACKED) return 0;
18124
18125 return -1;
18126 }
Hashcat additions to support pwdhash