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 #if defined(DARWIN) || defined(__FreeBSD__)
  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 STDOUT_FLAG             0
  37 #define RESTORE                 0
  38 #define RESTORE_TIMER           60
  39 #define RESTORE_DISABLE         0
  40 #define STATUS                  0
  41 #define STATUS_TIMER            10
  42 #define MACHINE_READABLE        0
  43 #define LOOPBACK                0
  44 #define WEAK_HASH_THRESHOLD     100
  45 #define SHOW                    0
  46 #define LEFT                    0
  47 #define USERNAME                0
  48 #define REMOVE                  0
  49 #define REMOVE_TIMER            60
  50 #define SKIP                    0
  51 #define LIMIT                   0
  52 #define KEYSPACE                0
  53 #define POTFILE_DISABLE         0
  54 #define DEBUG_MODE              0
  55 #define RP_GEN                  0
  56 #define RP_GEN_FUNC_MIN         1
  57 #define RP_GEN_FUNC_MAX         4
  58 #define RP_GEN_SEED             0
  59 #define RULE_BUF_L              ":"
  60 #define RULE_BUF_R              ":"
  61 #define FORCE                   0
  62 #define RUNTIME                 0
  63 #define HEX_CHARSET             0
  64 #define HEX_SALT                0
  65 #define HEX_WORDLIST            0
  66 #define OUTFILE_FORMAT          3
  67 #define OUTFILE_AUTOHEX         1
  68 #define OUTFILE_CHECK_TIMER     5
  69 #define ATTACK_MODE             0
  70 #define HASH_MODE               0
  71 #define SEGMENT_SIZE            32
  72 #define INCREMENT               0
  73 #define INCREMENT_MIN           1
  74 #define INCREMENT_MAX           PW_MAX
  75 #define SEPARATOR               ':'
  76 #define BITMAP_MIN              16
  77 #define BITMAP_MAX              24
  78 #define NVIDIA_SPIN_DAMP        100
  79 #define GPU_TEMP_DISABLE        0
  80 #define GPU_TEMP_ABORT          90
  81 #define GPU_TEMP_RETAIN         75
  82 #define WORKLOAD_PROFILE        2
  83 #define KERNEL_ACCEL            0
  84 #define KERNEL_LOOPS            0
  85 #define KERNEL_RULES            1024
  86 #define KERNEL_COMBS            1024
  87 #define KERNEL_BFS              1024
  88 #define KERNEL_THREADS_MAX      256
  89 #define KERNEL_THREADS_MAX_CPU  1
  90 #define POWERTUNE_ENABLE        0
  91 #define LOGFILE_DISABLE         0
  92 #define SCRYPT_TMTO             0
  93 #define OPENCL_VECTOR_WIDTH     0
  94
  95 #define WL_MODE_STDIN           1
  96 #define WL_MODE_FILE            2
  97 #define WL_MODE_MASK            3
  98
  99 #define HL_MODE_FILE            4
 100 #define HL_MODE_ARG             5
 101
 102 #define HLFMTS_CNT              11
 103 #define HLFMT_HASHCAT           0
 104 #define HLFMT_PWDUMP            1
 105 #define HLFMT_PASSWD            2
 106 #define HLFMT_SHADOW            3
 107 #define HLFMT_DCC               4
 108 #define HLFMT_DCC2              5
 109 #define HLFMT_NETNTLM1          7
 110 #define HLFMT_NETNTLM2          8
 111 #define HLFMT_NSLDAP            9
 112 #define HLFMT_NSLDAPS           10
 113
 114 #define HLFMT_TEXT_HASHCAT      "native hashcat"
 115 #define HLFMT_TEXT_PWDUMP       "pwdump"
 116 #define HLFMT_TEXT_PASSWD       "passwd"
 117 #define HLFMT_TEXT_SHADOW       "shadow"
 118 #define HLFMT_TEXT_DCC          "DCC"
 119 #define HLFMT_TEXT_DCC2         "DCC 2"
 120 #define HLFMT_TEXT_NETNTLM1     "NetNTLMv1"
 121 #define HLFMT_TEXT_NETNTLM2     "NetNTLMv2"
 122 #define HLFMT_TEXT_NSLDAP       "nsldap"
 123 #define HLFMT_TEXT_NSLDAPS      "nsldaps"
 124
 125 #define ATTACK_MODE_STRAIGHT    0
 126 #define ATTACK_MODE_COMBI       1
 127 #define ATTACK_MODE_TOGGLE      2
 128 #define ATTACK_MODE_BF          3
 129 #define ATTACK_MODE_PERM        4
 130 #define ATTACK_MODE_TABLE       5
 131 #define ATTACK_MODE_HYBRID1     6
 132 #define ATTACK_MODE_HYBRID2     7
 133 #define ATTACK_MODE_NONE        100
 134
 135 #define ATTACK_KERN_STRAIGHT    0
 136 #define ATTACK_KERN_COMBI       1
 137 #define ATTACK_KERN_BF          3
 138 #define ATTACK_KERN_NONE        100
 139
 140 #define ATTACK_EXEC_OUTSIDE_KERNEL  10
 141 #define ATTACK_EXEC_INSIDE_KERNEL   11
 142
 143 #define COMBINATOR_MODE_BASE_LEFT   10001
 144 #define COMBINATOR_MODE_BASE_RIGHT  10002
 145
 146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 148
 149 #define MAX_CUT_TRIES           4
 150
 151 #define MAX_DICTSTAT            10000
 152
 153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
 154
 155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
 156
 157 #define global_free(attr)       \
 158 {                               \
 159   myfree ((void *) data.attr);  \
 160                                 \
 161   data.attr = NULL;             \
 162 }
 163
 164 #define local_free(attr)  \
 165 {                         \
 166   myfree ((void *) attr); \
 167                           \
 168   attr = NULL;            \
 169 }
 170
 171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 172 #define HC_API_CALL __stdcall
 173 #else
 174 #define HC_API_CALL
 175 #endif
 176
 177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
 178 {
 179   900,
 180   0,
 181   5100,
 182   100,
 183   1400,
 184   10800,
 185   1700,
 186   5000,
 187   10100,
 188   6000,
 189   6100,
 190   6900,
 191   11700,
 192   11800,
 193   400,
 194   8900,
 195   11900,
 196   12000,
 197   10900,
 198   12100,
 199   23,
 200   2500,
 201   5300,
 202   5400,
 203   5500,
 204   5600,
 205   7300,
 206   7500,
 207   13100,
 208   8300,
 209   11100,
 210   11200,
 211   11400,
 212   121,
 213   2611,
 214   2711,
 215   2811,
 216   8400,
 217   11,
 218   2612,
 219   7900,
 220   21,
 221   11000,
 222   124,
 223   10000,
 224   3711,
 225   7600,
 226   12,
 227   131,
 228   132,
 229   1731,
 230   200,
 231   300,
 232   3100,
 233   112,
 234   12300,
 235   8000,
 236   141,
 237   1441,
 238   1600,
 239   12600,
 240   1421,
 241   101,
 242   111,
 243   1711,
 244   3000,
 245   1000,
 246   1100,
 247   2100,
 248   12800,
 249   1500,
 250   12400,
 251   500,
 252   3200,
 253   7400,
 254   1800,
 255   122,
 256   1722,
 257   7100,
 258   6300,
 259   6700,
 260   6400,
 261   6500,
 262   2400,
 263   2410,
 264   5700,
 265   9200,
 266   9300,
 267   22,
 268   501,
 269   5800,
 270   8100,
 271   8500,
 272   7200,
 273   9900,
 274   7700,
 275   7800,
 276   10300,
 277   8600,
 278   8700,
 279   9100,
 280   133,
 281   13500,
 282   11600,
 283   13600,
 284   12500,
 285   13000,
 286   13200,
 287   13300,
 288   6211,
 289   6221,
 290   6231,
 291   6241,
 292   13711,
 293   13721,
 294   13731,
 295   13741,
 296   13751,
 297   13761,
 298   8800,
 299   12900,
 300   12200,
 301   9700,
 302   9710,
 303   9800,
 304   9810,
 305   9400,
 306   9500,
 307   9600,
 308   10400,
 309   10410,
 310   10500,
 311   10600,
 312   10700,
 313   9000,
 314   5200,
 315   6800,
 316   6600,
 317   8200,
 318   11300,
 319   12700,
 320   13400,
 321   125
 322 };
 323
 324 /**
 325  * types
 326  */
 327
 328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
 329
 330 /**
 331  * globals
 332  */
 333
 334 static unsigned int full01 = 0x01010101;
 335 static unsigned int full80 = 0x80808080;
 336
 337 int SUPPRESS_OUTPUT = 0;
 338
 339 hc_thread_mutex_t mux_adl;
 340 hc_thread_mutex_t mux_counter;
 341 hc_thread_mutex_t mux_dispatcher;
 342 hc_thread_mutex_t mux_display;
 343
 344 hc_global_data_t data;
 345
 346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
 347
 348 const char *USAGE_MINI[] =
 349 {
 350   "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
 351   "",
 352   "Try --help for more help.",
 353   NULL
 354 };
 355
 356 const char *USAGE_BIG[] =
 357 {
 358   "%s, advanced password recovery",
 359   "",
 360   "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
 361   "",
 362   "- [ Options ] -",
 363   "",
 364   " Options Short / Long          | Type | Description                                          | Example",
 365   "===============================+======+======================================================+=======================",
 366   " -m, --hash-type               | Num  | Hash-type, see references below                      | -m 1000",
 367   " -a, --attack-mode             | Num  | Attack-mode, see references below                    | -a 3",
 368   " -V, --version                 |      | Print version                                        |",
 369   " -h, --help                    |      | Print help                                           |",
 370   "     --quiet                   |      | Suppress output                                      |",
 371   "     --hex-charset             |      | Assume charset is given in hex                       |",
 372   "     --hex-salt                |      | Assume salt is given in hex                          |",
 373   "     --hex-wordlist            |      | Assume words in wordlist is given in hex             |",
 374   "     --force                   |      | Ignore warnings                                      |",
 375   "     --status                  |      | Enable automatic update of the status-screen         |",
 376   "     --status-timer            | Num  | Sets seconds between status-screen update to X       | --status-timer=1",
 377   "     --machine-readable        |      | Display the status view in a machine readable format |",
 378   "     --loopback                |      | Add new plains to induct directory                   |",
 379   "     --weak-hash-threshold     | Num  | Threshold X when to stop checking for weak hashes    | --weak=0",
 380   "     --markov-hcstat           | File | Specify hcstat file to use                           | --markov-hc=my.hcstat",
 381   "     --markov-disable          |      | Disables markov-chains, emulates classic brute-force |",
 382   "     --markov-classic          |      | Enables classic markov-chains, no per-position       |",
 383   " -t, --markov-threshold        | Num  | Threshold X when to stop accepting new markov-chains | -t 50",
 384   "     --runtime                 | Num  | Abort session after X seconds of runtime             | --runtime=10",
 385   "     --session                 | Str  | Define specific session name                         | --session=mysession",
 386   "     --restore                 |      | Restore session from --session                       |",
 387   "     --restore-disable         |      | Do not write restore file                            |",
 388   " -o, --outfile                 | File | Define outfile for recovered hash                    | -o outfile.txt",
 389   "     --outfile-format          | Num  | Define outfile-format X for recovered hash           | --outfile-format=7",
 390   "     --outfile-autohex-disable |      | Disable the use of $HEX[] in output plains           |",
 391   "     --outfile-check-timer     | Num  | Sets seconds between outfile checks to X             | --outfile-check=30",
 392   " -p, --separator               | Char | Separator char for hashlists and outfile             | -p :",
 393   "     --stdout                  |      | Do not crack a hash, instead print candidates only   |",
 394   "     --show                    |      | Compare hashlist with potfile; Show cracked hashes   |",
 395   "     --left                    |      | Compare hashlist with potfile; Show uncracked hashes |",
 396   "     --username                |      | Enable ignoring of usernames in hashfile             |",
 397   "     --remove                  |      | Enable remove of hash once it is cracked             |",
 398   "     --remove-timer            | Num  | Update input hash file each X seconds                | --remove-timer=30",
 399   "     --potfile-disable         |      | Do not write potfile                                 |",
 400   "     --potfile-path            | Dir  | Specific path to potfile                             | --potfile-path=my.pot",
 401   "     --debug-mode              | Num  | Defines the debug mode (hybrid only by using rules)  | --debug-mode=4",
 402   "     --debug-file              | File | Output file for debugging rules                      | --debug-file=good.log",
 403   "     --induction-dir           | Dir  | Specify the induction directory to use for loopback  | --induction=inducts",
 404   "     --outfile-check-dir       | Dir  | Specify the outfile directory to monitor for plains  | --outfile-check-dir=x",
 405   "     --logfile-disable         |      | Disable the logfile                                  |",
 406   "     --truecrypt-keyfiles      | File | Keyfiles used, separate with comma                   | --truecrypt-key=x.png",
 407   "     --veracrypt-keyfiles      | File | Keyfiles used, separate with comma                   | --veracrypt-key=x.txt",
 408   "     --veracrypt-pim           | Num  | VeraCrypt personal iterations multiplier             | --veracrypt-pim=1000",
 409   " -b, --benchmark               |      | Run benchmark                                        |",
 410   " -c, --segment-size            | Num  | Sets size in MB to cache from the wordfile to X      | -c 32",
 411   "     --bitmap-min              | Num  | Sets minimum bits allowed for bitmaps to X           | --bitmap-min=24",
 412   "     --bitmap-max              | Num  | Sets maximum bits allowed for bitmaps to X           | --bitmap-min=24",
 413   "     --cpu-affinity            | Str  | Locks to CPU devices, separate with comma            | --cpu-affinity=1,2,3",
 414   "     --opencl-platforms        | Str  | OpenCL platforms to use, separate with comma         | --opencl-platforms=2",
 415   " -d, --opencl-devices          | Str  | OpenCL devices to use, separate with comma           | -d 1",
 416   " -D, --opencl-device-types     | Str  | OpenCL device-types to use, separate with comma      | -D 1",
 417   "     --opencl-vector-width     | Num  | Manual override OpenCL vector-width to X             | --opencl-vector=4",
 418   " -w, --workload-profile        | Num  | Enable a specific workload profile, see pool below   | -w 3",
 419   " -n, --kernel-accel            | Num  | Manual workload tuning, set outerloop step size to X | -n 64",
 420   " -u, --kernel-loops            | Num  | Manual workload tuning, set innerloop step size to X | -u 256",
 421   "     --nvidia-spin-damp        | Num  | Workaround NVidias CPU burning loop bug, in percent  | --nvidia-spin-damp=50",
 422   "     --gpu-temp-disable        |      | Disable temperature and fanspeed reads and triggers  |",
 423   #ifdef HAVE_HWMON
 424   "     --gpu-temp-abort          | Num  | Abort if GPU temperature reaches X degrees celsius   | --gpu-temp-abort=100",
 425   "     --gpu-temp-retain         | Num  | Try to retain GPU temperature at X degrees celsius   | --gpu-temp-retain=95",
 426   "     --powertune-enable        |      | Enable power tuning, restores settings when finished |",
 427   #endif
 428   "     --scrypt-tmto             | Num  | Manually override TMTO value for scrypt to X         | --scrypt-tmto=3",
 429   " -s, --skip                    | Num  | Skip X words from the start                          | -s 1000000",
 430   " -l, --limit                   | Num  | Limit X words from the start + skipped words         | -l 1000000",
 431   "     --keyspace                |      | Show keyspace base:mod values and quit               |",
 432   " -j, --rule-left               | Rule | Single rule applied to each word from left wordlist  | -j 'c'",
 433   " -k, --rule-right              | Rule | Single rule applied to each word from right wordlist | -k '^-'",
 434   " -r, --rules-file              | File | Multiple rules applied to each word from wordlists   | -r rules/best64.rule",
 435   " -g, --generate-rules          | Num  | Generate X random rules                              | -g 10000",
 436   "     --generate-rules-func-min | Num  | Force min X funcs per rule                           |",
 437   "     --generate-rules-func-max | Num  | Force max X funcs per rule                           |",
 438   "     --generate-rules-seed     | Num  | Force RNG seed set to X                              |",
 439   " -1, --custom-charset1         | CS   | User-defined charset ?1                              | -1 ?l?d?u",
 440   " -2, --custom-charset2         | CS   | User-defined charset ?2                              | -2 ?l?d?s",
 441   " -3, --custom-charset3         | CS   | User-defined charset ?3                              |",
 442   " -4, --custom-charset4         | CS   | User-defined charset ?4                              |",
 443   " -i, --increment               |      | Enable mask increment mode                           |",
 444   "     --increment-min           | Num  | Start mask incrementing at X                         | --increment-min=4",
 445   "     --increment-max           | Num  | Stop mask incrementing at X                          | --increment-max=8",
 446   "",
 447   "- [ Hash modes ] -",
 448   "",
 449   "      # | Name                                             | Category",
 450   "  ======+==================================================+======================================",
 451   "    900 | MD4                                              | Raw Hash",
 452   "      0 | MD5                                              | Raw Hash",
 453   "   5100 | Half MD5                                         | Raw Hash",
 454   "    100 | SHA1                                             | Raw Hash",
 455   "  10800 | SHA-384                                          | Raw Hash",
 456   "   1400 | SHA-256                                          | Raw Hash",
 457   "   1700 | SHA-512                                          | Raw Hash",
 458   "   5000 | SHA-3(Keccak)                                    | Raw Hash",
 459   "  10100 | SipHash                                          | Raw Hash",
 460   "   6000 | RipeMD160                                        | Raw Hash",
 461   "   6100 | Whirlpool                                        | Raw Hash",
 462   "   6900 | GOST R 34.11-94                                  | Raw Hash",
 463   "  11700 | GOST R 34.11-2012 (Streebog) 256-bit             | Raw Hash",
 464   "  11800 | GOST R 34.11-2012 (Streebog) 512-bit             | Raw Hash",
 465   "     10 | md5($pass.$salt)                                 | Raw Hash, Salted and / or Iterated",
 466   "     20 | md5($salt.$pass)                                 | Raw Hash, Salted and / or Iterated",
 467   "     30 | md5(unicode($pass).$salt)                        | Raw Hash, Salted and / or Iterated",
 468   "     40 | md5($salt.unicode($pass))                        | Raw Hash, Salted and / or Iterated",
 469   "   3800 | md5($salt.$pass.$salt)                           | Raw Hash, Salted and / or Iterated",
 470   "   3710 | md5($salt.md5($pass))                            | Raw Hash, Salted and / or Iterated",
 471   "   2600 | md5(md5($pass))                                  | Raw Hash, Salted and / or Iterated",
 472   "   4300 | md5(strtoupper(md5($pass)))                      | Raw Hash, Salted and / or Iterated",
 473   "   4400 | md5(sha1($pass))                                 | Raw Hash, Salted and / or Iterated",
 474   "    110 | sha1($pass.$salt)                                | Raw Hash, Salted and / or Iterated",
 475   "    120 | sha1($salt.$pass)                                | Raw Hash, Salted and / or Iterated",
 476   "    130 | sha1(unicode($pass).$salt)                       | Raw Hash, Salted and / or Iterated",
 477   "    140 | sha1($salt.unicode($pass))                       | Raw Hash, Salted and / or Iterated",
 478   "   4500 | sha1(sha1($pass))                                | Raw Hash, Salted and / or Iterated",
 479   "   4700 | sha1(md5($pass))                                 | Raw Hash, Salted and / or Iterated",
 480   "   4900 | sha1($salt.$pass.$salt)                          | Raw Hash, Salted and / or Iterated",
 481   "   1410 | sha256($pass.$salt)                              | Raw Hash, Salted and / or Iterated",
 482   "   1420 | sha256($salt.$pass)                              | Raw Hash, Salted and / or Iterated",
 483   "   1430 | sha256(unicode($pass).$salt)                     | Raw Hash, Salted and / or Iterated",
 484   "   1440 | sha256($salt.unicode($pass))                     | Raw Hash, Salted and / or Iterated",
 485   "   1710 | sha512($pass.$salt)                              | Raw Hash, Salted and / or Iterated",
 486   "   1720 | sha512($salt.$pass)                              | Raw Hash, Salted and / or Iterated",
 487   "   1730 | sha512(unicode($pass).$salt)                     | Raw Hash, Salted and / or Iterated",
 488   "   1740 | sha512($salt.unicode($pass))                     | Raw Hash, Salted and / or Iterated",
 489   "     50 | HMAC-MD5 (key = $pass)                           | Raw Hash, Authenticated",
 490   "     60 | HMAC-MD5 (key = $salt)                           | Raw Hash, Authenticated",
 491   "    150 | HMAC-SHA1 (key = $pass)                          | Raw Hash, Authenticated",
 492   "    160 | HMAC-SHA1 (key = $salt)                          | Raw Hash, Authenticated",
 493   "   1450 | HMAC-SHA256 (key = $pass)                        | Raw Hash, Authenticated",
 494   "   1460 | HMAC-SHA256 (key = $salt)                        | Raw Hash, Authenticated",
 495   "   1750 | HMAC-SHA512 (key = $pass)                        | Raw Hash, Authenticated",
 496   "   1760 | HMAC-SHA512 (key = $salt)                        | Raw Hash, Authenticated",
 497   "    400 | phpass                                           | Generic KDF",
 498   "   8900 | scrypt                                           | Generic KDF",
 499   "  11900 | PBKDF2-HMAC-MD5                                  | Generic KDF",
 500   "  12000 | PBKDF2-HMAC-SHA1                                 | Generic KDF",
 501   "  10900 | PBKDF2-HMAC-SHA256                               | Generic KDF",
 502   "  12100 | PBKDF2-HMAC-SHA512                               | Generic KDF",
 503   "     23 | Skype                                            | Network protocols",
 504   "   2500 | WPA/WPA2                                         | Network protocols",
 505   "   4800 | iSCSI CHAP authentication, MD5(Chap)             | Network protocols",
 506   "   5300 | IKE-PSK MD5                                      | Network protocols",
 507   "   5400 | IKE-PSK SHA1                                     | Network protocols",
 508   "   5500 | NetNTLMv1                                        | Network protocols",
 509   "   5500 | NetNTLMv1 + ESS                                  | Network protocols",
 510   "   5600 | NetNTLMv2                                        | Network protocols",
 511   "   7300 | IPMI2 RAKP HMAC-SHA1                             | Network protocols",
 512   "   7500 | Kerberos 5 AS-REQ Pre-Auth etype 23              | Network protocols",
 513   "   8300 | DNSSEC (NSEC3)                                   | Network protocols",
 514   "  10200 | Cram MD5                                         | Network protocols",
 515   "  11100 | PostgreSQL CRAM (MD5)                            | Network protocols",
 516   "  11200 | MySQL CRAM (SHA1)                                | Network protocols",
 517   "  11400 | SIP digest authentication (MD5)                  | Network protocols",
 518   "  13100 | Kerberos 5 TGS-REP etype 23                      | Network protocols",
 519   "    121 | SMF (Simple Machines Forum)                      | Forums, CMS, E-Commerce, Frameworks",
 520   "    400 | phpBB3                                           | Forums, CMS, E-Commerce, Frameworks",
 521   "   2611 | vBulletin < v3.8.5                               | Forums, CMS, E-Commerce, Frameworks",
 522   "   2711 | vBulletin > v3.8.5                               | Forums, CMS, E-Commerce, Frameworks",
 523   "   2811 | MyBB                                             | Forums, CMS, E-Commerce, Frameworks",
 524   "   2811 | IPB (Invison Power Board)                        | Forums, CMS, E-Commerce, Frameworks",
 525   "   8400 | WBB3 (Woltlab Burning Board)                     | Forums, CMS, E-Commerce, Frameworks",
 526   "     11 | Joomla < 2.5.18                                  | Forums, CMS, E-Commerce, Frameworks",
 527   "    400 | Joomla > 2.5.18                                  | Forums, CMS, E-Commerce, Frameworks",
 528   "    400 | Wordpress                                        | Forums, CMS, E-Commerce, Frameworks",
 529   "   2612 | PHPS                                             | Forums, CMS, E-Commerce, Frameworks",
 530   "   7900 | Drupal7                                          | Forums, CMS, E-Commerce, Frameworks",
 531   "     21 | osCommerce                                       | Forums, CMS, E-Commerce, Frameworks",
 532   "     21 | xt:Commerce                                      | Forums, CMS, E-Commerce, Frameworks",
 533   "  11000 | PrestaShop                                       | Forums, CMS, E-Commerce, Frameworks",
 534   "    124 | Django (SHA-1)                                   | Forums, CMS, E-Commerce, Frameworks",
 535   "  10000 | Django (PBKDF2-SHA256)                           | Forums, CMS, E-Commerce, Frameworks",
 536   "   3711 | Mediawiki B type                                 | Forums, CMS, E-Commerce, Frameworks",
 537   "   7600 | Redmine                                          | Forums, CMS, E-Commerce, Frameworks",
 538   "     12 | PostgreSQL                                       | Database Server",
 539   "    131 | MSSQL(2000)                                      | Database Server",
 540   "    132 | MSSQL(2005)                                      | Database Server",
 541   "   1731 | MSSQL(2012)                                      | Database Server",
 542   "   1731 | MSSQL(2014)                                      | Database Server",
 543   "    200 | MySQL323                                         | Database Server",
 544   "    300 | MySQL4.1/MySQL5                                  | Database Server",
 545   "   3100 | Oracle H: Type (Oracle 7+)                       | Database Server",
 546   "    112 | Oracle S: Type (Oracle 11+)                      | Database Server",
 547   "  12300 | Oracle T: Type (Oracle 12+)                      | Database Server",
 548   "   8000 | Sybase ASE                                       | Database Server",
 549   "    141 | EPiServer 6.x < v4                               | HTTP, SMTP, LDAP Server",
 550   "   1441 | EPiServer 6.x > v4                               | HTTP, SMTP, LDAP Server",
 551   "   1600 | Apache $apr1$                                    | HTTP, SMTP, LDAP Server",
 552   "  12600 | ColdFusion 10+                                   | HTTP, SMTP, LDAP Server",
 553   "   1421 | hMailServer                                      | HTTP, SMTP, LDAP Server",
 554   "    101 | nsldap, SHA-1(Base64), Netscape LDAP SHA         | HTTP, SMTP, LDAP Server",
 555   "    111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA      | HTTP, SMTP, LDAP Server",
 556   "   1711 | SSHA-512(Base64), LDAP {SSHA512}                 | HTTP, SMTP, LDAP Server",
 557   "  11500 | CRC32                                            | Checksums",
 558   "   3000 | LM                                               | Operating-Systems",
 559   "   1000 | NTLM                                             | Operating-Systems",
 560   "   1100 | Domain Cached Credentials (DCC), MS Cache        | Operating-Systems",
 561   "   2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2   | Operating-Systems",
 562   "  12800 | MS-AzureSync PBKDF2-HMAC-SHA256                  | Operating-Systems",
 563   "   1500 | descrypt, DES(Unix), Traditional DES             | Operating-Systems",
 564   "  12400 | BSDiCrypt, Extended DES                          | Operating-Systems",
 565   "    500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems",
 566   "   3200 | bcrypt $2*$, Blowfish(Unix)                      | Operating-Systems",
 567   "   7400 | sha256crypt $5$, SHA256(Unix)                    | Operating-Systems",
 568   "   1800 | sha512crypt $6$, SHA512(Unix)                    | Operating-Systems",
 569   "    122 | OSX v10.4, OSX v10.5, OSX v10.6                  | Operating-Systems",
 570   "   1722 | OSX v10.7                                        | Operating-Systems",
 571   "   7100 | OSX v10.8, OSX v10.9, OSX v10.10                 | Operating-Systems",
 572   "   6300 | AIX {smd5}                                       | Operating-Systems",
 573   "   6700 | AIX {ssha1}                                      | Operating-Systems",
 574   "   6400 | AIX {ssha256}                                    | Operating-Systems",
 575   "   6500 | AIX {ssha512}                                    | Operating-Systems",
 576   "   2400 | Cisco-PIX                                        | Operating-Systems",
 577   "   2410 | Cisco-ASA                                        | Operating-Systems",
 578   "    500 | Cisco-IOS $1$                                    | Operating-Systems",
 579   "   5700 | Cisco-IOS $4$                                    | Operating-Systems",
 580   "   9200 | Cisco-IOS $8$                                    | Operating-Systems",
 581   "   9300 | Cisco-IOS $9$                                    | Operating-Systems",
 582   "     22 | Juniper Netscreen/SSG (ScreenOS)                 | Operating-Systems",
 583   "    501 | Juniper IVE                                      | Operating-Systems",
 584   "   5800 | Android PIN                                      | Operating-Systems",
 585   "  13800 | Windows 8+ phone PIN/Password                    | Operating-Systems",
 586   "   8100 | Citrix Netscaler                                 | Operating-Systems",
 587   "   8500 | RACF                                             | Operating-Systems",
 588   "   7200 | GRUB 2                                           | Operating-Systems",
 589   "   9900 | Radmin2                                          | Operating-Systems",
 590   "    125 | ArubaOS                                          | Operating-Systems",
 591   "   7700 | SAP CODVN B (BCODE)                              | Enterprise Application Software (EAS)",
 592   "   7800 | SAP CODVN F/G (PASSCODE)                         | Enterprise Application Software (EAS)",
 593   "  10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1              | Enterprise Application Software (EAS)",
 594   "   8600 | Lotus Notes/Domino 5                             | Enterprise Application Software (EAS)",
 595   "   8700 | Lotus Notes/Domino 6                             | Enterprise Application Software (EAS)",
 596   "   9100 | Lotus Notes/Domino 8                             | Enterprise Application Software (EAS)",
 597   "    133 | PeopleSoft                                       | Enterprise Application Software (EAS)",
 598   "  13500 | PeopleSoft Token                                 | Enterprise Application Software (EAS)",
 599   "  11600 | 7-Zip                                            | Archives",
 600   "  12500 | RAR3-hp                                          | Archives",
 601   "  13000 | RAR5                                             | Archives",
 602   "  13200 | AxCrypt                                          | Archives",
 603   "  13300 | AxCrypt in memory SHA1                           | Archives",
 604   "  13600 | WinZip                                           | Archives",
 605   "   62XY | TrueCrypt                                        | Full-Disk encryptions (FDE)",
 606   "     X  | 1 = PBKDF2-HMAC-RipeMD160                        | Full-Disk encryptions (FDE)",
 607   "     X  | 2 = PBKDF2-HMAC-SHA512                           | Full-Disk encryptions (FDE)",
 608   "     X  | 3 = PBKDF2-HMAC-Whirlpool                        | Full-Disk encryptions (FDE)",
 609   "     X  | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode            | Full-Disk encryptions (FDE)",
 610   "      Y | 1 = XTS  512 bit pure AES                        | Full-Disk encryptions (FDE)",
 611   "      Y | 1 = XTS  512 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 612   "      Y | 1 = XTS  512 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 613   "      Y | 2 = XTS 1024 bit pure AES                        | Full-Disk encryptions (FDE)",
 614   "      Y | 2 = XTS 1024 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 615   "      Y | 2 = XTS 1024 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 616   "      Y | 2 = XTS 1024 bit cascaded AES-Twofish            | Full-Disk encryptions (FDE)",
 617   "      Y | 2 = XTS 1024 bit cascaded Serpent-AES            | Full-Disk encryptions (FDE)",
 618   "      Y | 2 = XTS 1024 bit cascaded Twofish-Serpent        | Full-Disk encryptions (FDE)",
 619   "      Y | 3 = XTS 1536 bit all                             | Full-Disk encryptions (FDE)",
 620   "   8800 | Android FDE < v4.3                               | Full-Disk encryptions (FDE)",
 621   "  12900 | Android FDE (Samsung DEK)                        | Full-Disk encryptions (FDE)",
 622   "  12200 | eCryptfs                                         | Full-Disk encryptions (FDE)",
 623   "  137XY | VeraCrypt                                        | Full-Disk encryptions (FDE)",
 624   "     X  | 1 = PBKDF2-HMAC-RipeMD160                        | Full-Disk encryptions (FDE)",
 625   "     X  | 2 = PBKDF2-HMAC-SHA512                           | Full-Disk encryptions (FDE)",
 626   "     X  | 3 = PBKDF2-HMAC-Whirlpool                        | Full-Disk encryptions (FDE)",
 627   "     X  | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode            | Full-Disk encryptions (FDE)",
 628   "     X  | 5 = PBKDF2-HMAC-SHA256                           | Full-Disk encryptions (FDE)",
 629   "     X  | 6 = PBKDF2-HMAC-SHA256 + boot-mode               | Full-Disk encryptions (FDE)",
 630   "      Y | 1 = XTS  512 bit pure AES                        | Full-Disk encryptions (FDE)",
 631   "      Y | 1 = XTS  512 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 632   "      Y | 1 = XTS  512 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 633   "      Y | 2 = XTS 1024 bit pure AES                        | Full-Disk encryptions (FDE)",
 634   "      Y | 2 = XTS 1024 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 635   "      Y | 2 = XTS 1024 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 636   "      Y | 2 = XTS 1024 bit cascaded AES-Twofish            | Full-Disk encryptions (FDE)",
 637   "      Y | 2 = XTS 1024 bit cascaded Serpent-AES            | Full-Disk encryptions (FDE)",
 638   "      Y | 2 = XTS 1024 bit cascaded Twofish-Serpent        | Full-Disk encryptions (FDE)",
 639   "      Y | 3 = XTS 1536 bit all                             | Full-Disk encryptions (FDE)",
 640   "   9700 | MS Office <= 2003 $0|$1, MD5 + RC4               | Documents",
 641   "   9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1  | Documents",
 642   "   9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2  | Documents",
 643   "   9800 | MS Office <= 2003 $3|$4, SHA1 + RC4              | Documents",
 644   "   9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
 645   "   9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
 646   "   9400 | MS Office 2007                                   | Documents",
 647   "   9500 | MS Office 2010                                   | Documents",
 648   "   9600 | MS Office 2013                                   | Documents",
 649   "  10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4)                    | Documents",
 650   "  10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1       | Documents",
 651   "  10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2       | Documents",
 652   "  10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8)                    | Documents",
 653   "  10600 | PDF 1.7 Level 3 (Acrobat 9)                      | Documents",
 654   "  10700 | PDF 1.7 Level 8 (Acrobat 10 - 11)                | Documents",
 655   "   9000 | Password Safe v2                                 | Password Managers",
 656   "   5200 | Password Safe v3                                 | Password Managers",
 657   "   6800 | Lastpass + Lastpass sniffed                      | Password Managers",
 658   "   6600 | 1Password, agilekeychain                         | Password Managers",
 659   "   8200 | 1Password, cloudkeychain                         | Password Managers",
 660   "  11300 | Bitcoin/Litecoin wallet.dat                      | Password Managers",
 661   "  12700 | Blockchain, My Wallet                            | Password Managers",
 662   "  13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES)      | Password Managers",
 663   "",
 664   "- [ Outfile Formats ] -",
 665   "",
 666   "  # | Format",
 667   " ===+========",
 668   "  1 | hash[:salt]",
 669   "  2 | plain",
 670   "  3 | hash[:salt]:plain",
 671   "  4 | hex_plain",
 672   "  5 | hash[:salt]:hex_plain",
 673   "  6 | plain:hex_plain",
 674   "  7 | hash[:salt]:plain:hex_plain",
 675   "  8 | crackpos",
 676   "  9 | hash[:salt]:crack_pos",
 677   " 10 | plain:crack_pos",
 678   " 11 | hash[:salt]:plain:crack_pos",
 679   " 12 | hex_plain:crack_pos",
 680   " 13 | hash[:salt]:hex_plain:crack_pos",
 681   " 14 | plain:hex_plain:crack_pos",
 682   " 15 | hash[:salt]:plain:hex_plain:crack_pos",
 683   "",
 684   "- [ Rule Debugging Modes ] -",
 685   "",
 686   "  # | Format",
 687   " ===+========",
 688   "  1 | Finding-Rule",
 689   "  2 | Original-Word",
 690   "  3 | Original-Word:Finding-Rule",
 691   "  4 | Original-Word:Finding-Rule:Processed-Word",
 692   "",
 693   "- [ Attack Modes ] -",
 694   "",
 695   "  # | Mode",
 696   " ===+======",
 697   "  0 | Straight",
 698   "  1 | Combination",
 699   "  3 | Brute-force",
 700   "  6 | Hybrid Wordlist + Mask",
 701   "  7 | Hybrid Mask + Wordlist",
 702   "",
 703   "- [ Built-in Charsets ] -",
 704   "",
 705   "  ? | Charset",
 706   " ===+=========",
 707   "  l | abcdefghijklmnopqrstuvwxyz",
 708   "  u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
 709   "  d | 0123456789",
 710   "  s |  !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
 711   "  a | ?l?u?d?s",
 712   "  b | 0x00 - 0xff",
 713   "",
 714   "- [ OpenCL Device Types ] -",
 715   "",
 716   "  # | Device Type",
 717   " ===+=============",
 718   "  1 | CPU",
 719   "  2 | GPU",
 720   "  3 | FPGA, DSP, Co-Processor",
 721   "",
 722   "- [ Workload Profiles ] -",
 723   "",
 724   "  # | Performance | Runtime | Power Consumption | Desktop Impact",
 725   " ===+=============+=========+===================+=================",
 726   "  1 | Low         |   2 ms  | Low               | Minimal",
 727   "  2 | Default     |  12 ms  | Economic          | Noticeable",
 728   "  3 | High        |  96 ms  | High              | Unresponsive",
 729   "  4 | Nightmare   | 480 ms  | Insane            | Headless",
 730   "",
 731   "- [ Basic Examples ] -",
 732   "",
 733   "  Attack-          | Hash- |",
 734   "  Mode             | Type  | Example command",
 735   " ==================+=======+==================================================================",
 736   "  Wordlist         | $P$   | %s -a 0 -m 400 example400.hash example.dict",
 737   "  Wordlist + Rules | MD5   | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
 738   "  Brute-Force      | MD5   | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
 739   "  Combinator       | MD5   | %s -a 1 -m 0 example0.hash example.dict example.dict",
 740   "",
 741   "If you still have no idea what just happened try following pages:",
 742   "",
 743   "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
 744   "* https://hashcat.net/wiki/#frequently_asked_questions",
 745   NULL
 746 };
 747
 748 /**
 749  * hashcat specific functions
 750  */
 751
 752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
 753 {
 754   int exec_pos = (int) device_param->exec_pos - last_num_entries;
 755
 756   if (exec_pos < 0) exec_pos += EXEC_CACHE;
 757
 758   double exec_ms_sum = 0;
 759
 760   int exec_ms_cnt = 0;
 761
 762   for (int i = 0; i < last_num_entries; i++)
 763   {
 764     double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
 765
 766     if (exec_ms)
 767     {
 768       exec_ms_sum += exec_ms;
 769
 770       exec_ms_cnt++;
 771     }
 772   }
 773
 774   if (exec_ms_cnt == 0) return 0;
 775
 776   return exec_ms_sum / exec_ms_cnt;
 777 }
 778
 779 void status_display_machine_readable ()
 780 {
 781   FILE *out = stdout;
 782
 783   fprintf (out, "STATUS\t%u\t", data.devices_status);
 784
 785   /**
 786    * speed new
 787    */
 788
 789   fprintf (out, "SPEED\t");
 790
 791   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 792   {
 793     hc_device_param_t *device_param = &data.devices_param[device_id];
 794
 795     if (device_param->skipped) continue;
 796
 797     u64    speed_cnt  = 0;
 798     double speed_ms   = 0;
 799
 800     for (int i = 0; i < SPEED_CACHE; i++)
 801     {
 802       speed_cnt  += device_param->speed_cnt[i];
 803       speed_ms   += device_param->speed_ms[i];
 804     }
 805
 806     speed_cnt  /= SPEED_CACHE;
 807     speed_ms   /= SPEED_CACHE;
 808
 809     fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
 810   }
 811
 812   /**
 813    * exec time
 814    */
 815
 816   fprintf (out, "EXEC_RUNTIME\t");
 817
 818   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 819   {
 820     hc_device_param_t *device_param = &data.devices_param[device_id];
 821
 822     if (device_param->skipped) continue;
 823
 824     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
 825
 826     fprintf (out, "%f\t", exec_ms_avg);
 827   }
 828
 829   /**
 830    * words_cur
 831    */
 832
 833   u64 words_cur = get_lowest_words_done ();
 834
 835   fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
 836
 837   /**
 838    * counter
 839    */
 840
 841   u64 progress_total = data.words_cnt * data.salts_cnt;
 842
 843   u64 all_done     = 0;
 844   u64 all_rejected = 0;
 845   u64 all_restored = 0;
 846
 847   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
 848   {
 849     all_done     += data.words_progress_done[salt_pos];
 850     all_rejected += data.words_progress_rejected[salt_pos];
 851     all_restored += data.words_progress_restored[salt_pos];
 852   }
 853
 854   u64 progress_cur = all_restored + all_done + all_rejected;
 855   u64 progress_end = progress_total;
 856
 857   u64 progress_skip = 0;
 858
 859   if (data.skip)
 860   {
 861     progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
 862
 863     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
 864     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_skip *= data.combs_cnt;
 865     else if (data.attack_kern == ATTACK_KERN_BF)       progress_skip *= data.bfs_cnt;
 866   }
 867
 868   if (data.limit)
 869   {
 870     progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
 871
 872     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end  *= data.kernel_rules_cnt;
 873     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_end  *= data.combs_cnt;
 874     else if (data.attack_kern == ATTACK_KERN_BF)       progress_end  *= data.bfs_cnt;
 875   }
 876
 877   u64 progress_cur_relative_skip = progress_cur - progress_skip;
 878   u64 progress_end_relative_skip = progress_end - progress_skip;
 879
 880   fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
 881
 882   /**
 883    * cracks
 884    */
 885
 886   fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
 887   fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done,   data.salts_cnt);
 888
 889   /**
 890    * temperature
 891    */
 892
 893   #ifdef HAVE_HWMON
 894   if (data.gpu_temp_disable == 0)
 895   {
 896     fprintf (out, "TEMP\t");
 897
 898     hc_thread_mutex_lock (mux_adl);
 899
 900     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 901     {
 902       hc_device_param_t *device_param = &data.devices_param[device_id];
 903
 904       if (device_param->skipped) continue;
 905
 906       int temp = hm_get_temperature_with_device_id (device_id);
 907
 908       fprintf (out, "%d\t", temp);
 909     }
 910
 911     hc_thread_mutex_unlock (mux_adl);
 912   }
 913   #endif // HAVE_HWMON
 914
 915   /**
 916    * flush
 917    */
 918
 919   fputs (EOL, out);
 920   fflush (out);
 921 }
 922
 923 void status_display ()
 924 {
 925   if (data.devices_status == STATUS_INIT)     return;
 926   if (data.devices_status == STATUS_STARTING) return;
 927
 928   // in this case some required buffers are free'd, ascii_digest() would run into segfault
 929   if (data.shutdown_inner == 1) return;
 930
 931   if (data.machine_readable == 1)
 932   {
 933     status_display_machine_readable ();
 934
 935     return;
 936   }
 937
 938   char tmp_buf[1000] = { 0 };
 939
 940   uint tmp_len = 0;
 941
 942   log_info ("Session.Name...: %s", data.session);
 943
 944   char *status_type = strstatus (data.devices_status);
 945
 946   uint hash_mode = data.hash_mode;
 947
 948   char *hash_type = strhashtype (hash_mode); // not a bug
 949
 950   log_info ("Status.........: %s", status_type);
 951
 952   /**
 953    * show rules
 954    */
 955
 956   if (data.rp_files_cnt)
 957   {
 958     uint i;
 959
 960     for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
 961     {
 962       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
 963     }
 964
 965     snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
 966
 967     log_info ("Rules.Type.....: %s", tmp_buf);
 968
 969     tmp_len = 0;
 970   }
 971
 972   if (data.rp_gen)
 973   {
 974     log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
 975
 976     if (data.rp_gen_seed)
 977     {
 978       log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
 979     }
 980   }
 981
 982   /**
 983    * show input
 984    */
 985
 986   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
 987   {
 988     if (data.wordlist_mode == WL_MODE_FILE)
 989     {
 990       if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
 991     }
 992     else if (data.wordlist_mode == WL_MODE_STDIN)
 993     {
 994       log_info ("Input.Mode.....: Pipe");
 995     }
 996   }
 997   else if (data.attack_mode == ATTACK_MODE_COMBI)
 998   {
 999     if (data.dictfile  != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1000     if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1001   }
1002   else if (data.attack_mode == ATTACK_MODE_BF)
1003   {
1004     char *mask = data.mask;
1005
1006     if (mask != NULL)
1007     {
1008       uint mask_len = data.css_cnt;
1009
1010       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1011
1012       if (mask_len > 0)
1013       {
1014         if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1015         {
1016           if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1017           {
1018             mask_len -= data.salts_buf[0].salt_len;
1019           }
1020         }
1021
1022         if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1023
1024         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1025       }
1026
1027       if (data.maskcnt > 1)
1028       {
1029         float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1030
1031         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1032       }
1033
1034       log_info ("Input.Mode.....: %s", tmp_buf);
1035     }
1036
1037     tmp_len = 0;
1038   }
1039   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1040   {
1041     if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1042     if (data.mask     != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1043   }
1044   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1045   {
1046     if (data.mask     != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047     if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1048   }
1049
1050   if (data.digests_cnt == 1)
1051   {
1052     if (data.hash_mode == 2500)
1053     {
1054       wpa_t *wpa = (wpa_t *) data.esalts_buf;
1055
1056       log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1057                 (char *) data.salts_buf[0].salt_buf,
1058                 wpa->orig_mac1[0],
1059                 wpa->orig_mac1[1],
1060                 wpa->orig_mac1[2],
1061                 wpa->orig_mac1[3],
1062                 wpa->orig_mac1[4],
1063                 wpa->orig_mac1[5],
1064                 wpa->orig_mac2[0],
1065                 wpa->orig_mac2[1],
1066                 wpa->orig_mac2[2],
1067                 wpa->orig_mac2[3],
1068                 wpa->orig_mac2[4],
1069                 wpa->orig_mac2[5]);
1070     }
1071     else if (data.hash_mode == 5200)
1072     {
1073       log_info ("Hash.Target....: File (%s)", data.hashfile);
1074     }
1075     else if (data.hash_mode == 9000)
1076     {
1077       log_info ("Hash.Target....: File (%s)", data.hashfile);
1078     }
1079     else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1080     {
1081       log_info ("Hash.Target....: File (%s)", data.hashfile);
1082     }
1083     else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1084     {
1085       log_info ("Hash.Target....: File (%s)", data.hashfile);
1086     }
1087     else
1088     {
1089       char out_buf[HCBUFSIZ] = { 0 };
1090
1091       ascii_digest (out_buf, 0, 0);
1092
1093       // limit length
1094       if (strlen (out_buf) > 40)
1095       {
1096         out_buf[41] = '.';
1097         out_buf[42] = '.';
1098         out_buf[43] = '.';
1099         out_buf[44] = 0;
1100       }
1101
1102       log_info ("Hash.Target....: %s", out_buf);
1103     }
1104   }
1105   else
1106   {
1107     if (data.hash_mode == 3000)
1108     {
1109       char out_buf1[32] = { 0 };
1110       char out_buf2[32] = { 0 };
1111
1112       ascii_digest (out_buf1, 0, 0);
1113       ascii_digest (out_buf2, 0, 1);
1114
1115       log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1116     }
1117     else
1118     {
1119       log_info ("Hash.Target....: File (%s)", data.hashfile);
1120     }
1121   }
1122
1123   log_info ("Hash.Type......: %s", hash_type);
1124
1125   /**
1126    * speed new
1127    */
1128
1129   u64    speed_cnt[DEVICES_MAX] = { 0 };
1130   double speed_ms[DEVICES_MAX]  = { 0 };
1131
1132   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1133   {
1134     hc_device_param_t *device_param = &data.devices_param[device_id];
1135
1136     if (device_param->skipped) continue;
1137
1138     speed_cnt[device_id] = 0;
1139     speed_ms[device_id]  = 0;
1140
1141     for (int i = 0; i < SPEED_CACHE; i++)
1142     {
1143       speed_cnt[device_id] += device_param->speed_cnt[i];
1144       speed_ms[device_id]  += device_param->speed_ms[i];
1145     }
1146
1147     speed_cnt[device_id] /= SPEED_CACHE;
1148     speed_ms[device_id]  /= SPEED_CACHE;
1149   }
1150
1151   double hashes_all_ms = 0;
1152
1153   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1154
1155   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1156   {
1157     hc_device_param_t *device_param = &data.devices_param[device_id];
1158
1159     if (device_param->skipped) continue;
1160
1161     hashes_dev_ms[device_id] = 0;
1162
1163     if (speed_ms[device_id])
1164     {
1165       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1166
1167       hashes_all_ms += hashes_dev_ms[device_id];
1168     }
1169   }
1170
1171   /**
1172    * exec time
1173    */
1174
1175   double exec_all_ms[DEVICES_MAX] = { 0 };
1176
1177   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1178   {
1179     hc_device_param_t *device_param = &data.devices_param[device_id];
1180
1181     if (device_param->skipped) continue;
1182
1183     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1184
1185     exec_all_ms[device_id] = exec_ms_avg;
1186   }
1187
1188   /**
1189    * timers
1190    */
1191
1192   double ms_running = 0;
1193
1194   hc_timer_get (data.timer_running, ms_running);
1195
1196   double ms_paused = data.ms_paused;
1197
1198   if (data.devices_status == STATUS_PAUSED)
1199   {
1200     double ms_paused_tmp = 0;
1201
1202     hc_timer_get (data.timer_paused, ms_paused_tmp);
1203
1204     ms_paused += ms_paused_tmp;
1205   }
1206
1207   #ifdef WIN
1208
1209   __time64_t sec_run = ms_running / 1000;
1210
1211   #else
1212
1213   time_t sec_run = ms_running / 1000;
1214
1215   #endif
1216
1217   if (sec_run)
1218   {
1219     char display_run[32] = { 0 };
1220
1221     struct tm tm_run;
1222
1223     struct tm *tmp = NULL;
1224
1225     #ifdef WIN
1226
1227     tmp = _gmtime64 (&sec_run);
1228
1229     #else
1230
1231     tmp = gmtime (&sec_run);
1232
1233     #endif
1234
1235     if (tmp != NULL)
1236     {
1237       memset (&tm_run, 0, sizeof (tm_run));
1238
1239       memcpy (&tm_run, tmp, sizeof (tm_run));
1240
1241       format_timer_display (&tm_run, display_run, sizeof (tm_run));
1242
1243       char *start = ctime (&data.proc_start);
1244
1245       size_t start_len = strlen (start);
1246
1247       if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1248       if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1249
1250       log_info ("Time.Started...: %s (%s)", start, display_run);
1251     }
1252   }
1253   else
1254   {
1255     log_info ("Time.Started...: 0 secs");
1256   }
1257
1258   /**
1259    * counters
1260    */
1261
1262   u64 progress_total = data.words_cnt * data.salts_cnt;
1263
1264   u64 all_done     = 0;
1265   u64 all_rejected = 0;
1266   u64 all_restored = 0;
1267
1268   u64 progress_noneed = 0;
1269
1270   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1271   {
1272     all_done     += data.words_progress_done[salt_pos];
1273     all_rejected += data.words_progress_rejected[salt_pos];
1274     all_restored += data.words_progress_restored[salt_pos];
1275
1276     // Important for ETA only
1277
1278     if (data.salts_shown[salt_pos] == 1)
1279     {
1280       const u64 all = data.words_progress_done[salt_pos]
1281                     + data.words_progress_rejected[salt_pos]
1282                     + data.words_progress_restored[salt_pos];
1283
1284       const u64 left = data.words_cnt - all;
1285
1286       progress_noneed += left;
1287     }
1288   }
1289
1290   u64 progress_cur = all_restored + all_done + all_rejected;
1291   u64 progress_end = progress_total;
1292
1293   u64 progress_skip = 0;
1294
1295   if (data.skip)
1296   {
1297     progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1298
1299     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1300     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_skip *= data.combs_cnt;
1301     else if (data.attack_kern == ATTACK_KERN_BF)       progress_skip *= data.bfs_cnt;
1302   }
1303
1304   if (data.limit)
1305   {
1306     progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1307
1308     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end  *= data.kernel_rules_cnt;
1309     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_end  *= data.combs_cnt;
1310     else if (data.attack_kern == ATTACK_KERN_BF)       progress_end  *= data.bfs_cnt;
1311   }
1312
1313   u64 progress_cur_relative_skip = progress_cur - progress_skip;
1314   u64 progress_end_relative_skip = progress_end - progress_skip;
1315
1316   if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1317   {
1318     if (data.devices_status != STATUS_CRACKED)
1319     {
1320       #ifdef WIN
1321       __time64_t sec_etc = 0;
1322       #else
1323       time_t sec_etc = 0;
1324       #endif
1325
1326       if (hashes_all_ms)
1327       {
1328         u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1329
1330         u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1331
1332         sec_etc = ms_left / 1000;
1333       }
1334
1335       if (sec_etc == 0)
1336       {
1337         //log_info ("Time.Estimated.: 0 secs");
1338       }
1339       else if ((u64) sec_etc > ETC_MAX)
1340       {
1341         log_info ("Time.Estimated.: > 10 Years");
1342       }
1343       else
1344       {
1345         char display_etc[32]     = { 0 };
1346         char display_runtime[32] = { 0 };
1347
1348         struct tm tm_etc;
1349         struct tm tm_runtime;
1350
1351         struct tm *tmp = NULL;
1352
1353         #ifdef WIN
1354         tmp = _gmtime64 (&sec_etc);
1355         #else
1356         tmp = gmtime (&sec_etc);
1357         #endif
1358
1359         if (tmp != NULL)
1360         {
1361           memcpy (&tm_etc, tmp, sizeof (tm_etc));
1362
1363           format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1364
1365           time_t now;
1366
1367           time (&now);
1368
1369           now += sec_etc;
1370
1371           char *etc = ctime (&now);
1372
1373           size_t etc_len = strlen (etc);
1374
1375           if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1376           if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1377
1378           if (data.runtime)
1379           {
1380             time_t runtime_cur;
1381
1382             time (&runtime_cur);
1383
1384             #ifdef WIN
1385
1386             __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1387
1388             tmp = _gmtime64 (&runtime_left);
1389
1390             #else
1391
1392             time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1393
1394             tmp = gmtime (&runtime_left);
1395
1396             #endif
1397
1398             if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1399             {
1400               memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1401
1402               format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1403
1404               log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1405             }
1406             else
1407             {
1408               log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1409             }
1410           }
1411           else
1412           {
1413             log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1414           }
1415         }
1416       }
1417     }
1418   }
1419
1420   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421   {
1422     hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424     if (device_param->skipped) continue;
1425
1426     char display_dev_cur[16] = { 0 };
1427
1428     strncpy (display_dev_cur, "0.00", 4);
1429
1430     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432     log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1433   }
1434
1435   char display_all_cur[16] = { 0 };
1436
1437   strncpy (display_all_cur, "0.00", 4);
1438
1439   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441   if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443   const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444   const float salts_percent   = (float) data.salts_done   / data.salts_cnt;
1445
1446   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);
1447
1448   // crack-per-time
1449
1450   if (data.digests_cnt > 100)
1451   {
1452     time_t now = time (NULL);
1453
1454     int cpt_cur_min  = 0;
1455     int cpt_cur_hour = 0;
1456     int cpt_cur_day  = 0;
1457
1458     for (int i = 0; i < CPT_BUF; i++)
1459     {
1460       const uint   cracked   = data.cpt_buf[i].cracked;
1461       const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463       if ((timestamp + 60) > now)
1464       {
1465         cpt_cur_min  += cracked;
1466       }
1467
1468       if ((timestamp + 3600) > now)
1469       {
1470         cpt_cur_hour += cracked;
1471       }
1472
1473       if ((timestamp + 86400) > now)
1474       {
1475         cpt_cur_day  += cracked;
1476       }
1477     }
1478
1479     double ms_real = ms_running - ms_paused;
1480
1481     float cpt_avg_min  = (float) data.cpt_total / ((ms_real / 1000) / 60);
1482     float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1483     float cpt_avg_day  = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1484
1485     if ((data.cpt_start + 86400) < now)
1486     {
1487       log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488         cpt_cur_min,
1489         cpt_cur_hour,
1490         cpt_cur_day,
1491         cpt_avg_min,
1492         cpt_avg_hour,
1493         cpt_avg_day);
1494     }
1495     else if ((data.cpt_start + 3600) < now)
1496     {
1497       log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498         cpt_cur_min,
1499         cpt_cur_hour,
1500         cpt_avg_min,
1501         cpt_avg_hour,
1502         cpt_avg_day);
1503     }
1504     else if ((data.cpt_start + 60) < now)
1505     {
1506       log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1507         cpt_cur_min,
1508         cpt_avg_min,
1509         cpt_avg_hour,
1510         cpt_avg_day);
1511     }
1512     else
1513     {
1514       log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515         cpt_avg_min,
1516         cpt_avg_hour,
1517         cpt_avg_day);
1518     }
1519   }
1520
1521   // Restore point
1522
1523   u64 restore_point = get_lowest_words_done ();
1524
1525   u64 restore_total = data.words_base;
1526
1527   float percent_restore = 0;
1528
1529   if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1530
1531   if (progress_end_relative_skip)
1532   {
1533     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534     {
1535       float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1536       float percent_rejected = 0.0;
1537
1538       if (progress_cur)
1539       {
1540         percent_rejected = (float) (all_rejected) / (float) progress_cur;
1541       }
1542
1543       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);
1544       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected,               (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1545
1546       if (data.restore_disable == 0)
1547       {
1548         if (percent_finished != 1)
1549         {
1550           log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1551         }
1552       }
1553     }
1554   }
1555   else
1556   {
1557     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1558     {
1559       log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561
1562       if (data.restore_disable == 0)
1563       {
1564         log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565       }
1566     }
1567     else
1568     {
1569       log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1570       log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1571
1572       // --restore not allowed if stdin is used -- really? why?
1573
1574       //if (data.restore_disable == 0)
1575       //{
1576       //  log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1577       //}
1578     }
1579   }
1580
1581   #ifdef HAVE_HWMON
1582
1583   if (data.devices_status == STATUS_EXHAUSTED)  return;
1584   if (data.devices_status == STATUS_CRACKED)    return;
1585   if (data.devices_status == STATUS_ABORTED)    return;
1586   if (data.devices_status == STATUS_QUIT)       return;
1587
1588   if (data.gpu_temp_disable == 0)
1589   {
1590     hc_thread_mutex_lock (mux_adl);
1591
1592     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593     {
1594       hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596       if (device_param->skipped) continue;
1597
1598       const int num_temperature = hm_get_temperature_with_device_id (device_id);
1599       const int num_fanspeed    = hm_get_fanspeed_with_device_id    (device_id);
1600       const int num_utilization = hm_get_utilization_with_device_id (device_id);
1601       const int num_corespeed   = hm_get_corespeed_with_device_id   (device_id);
1602       const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1603       const int num_buslanes    = hm_get_buslanes_with_device_id    (device_id);
1604       const int num_throttle    = hm_get_throttle_with_device_id    (device_id);
1605
1606       char output_buf[256] = { 0 };
1607
1608       int output_len = 0;
1609
1610       if (num_temperature >= 0)
1611       {
1612         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1613
1614         output_len = strlen (output_buf);
1615       }
1616
1617       if (num_fanspeed >= 0)
1618       {
1619         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1620
1621         output_len = strlen (output_buf);
1622       }
1623
1624       if (num_utilization >= 0)
1625       {
1626         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1627
1628         output_len = strlen (output_buf);
1629       }
1630
1631       if (num_corespeed >= 0)
1632       {
1633         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1634
1635         output_len = strlen (output_buf);
1636       }
1637
1638       if (num_memoryspeed >= 0)
1639       {
1640         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1641
1642         output_len = strlen (output_buf);
1643       }
1644
1645       if (num_buslanes >= 0)
1646       {
1647         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1648
1649         output_len = strlen (output_buf);
1650       }
1651
1652       if (num_throttle == 1)
1653       {
1654         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1655
1656         output_len = strlen (output_buf);
1657       }
1658
1659       if (output_len == 0)
1660       {
1661         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1662
1663         output_len = strlen (output_buf);
1664       }
1665
1666       log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1667     }
1668
1669     hc_thread_mutex_unlock (mux_adl);
1670   }
1671
1672   #endif // HAVE_HWMON
1673 }
1674
1675 static void status_benchmark_automate ()
1676 {
1677   u64    speed_cnt[DEVICES_MAX] = { 0 };
1678   double speed_ms[DEVICES_MAX]  = { 0 };
1679
1680   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681   {
1682     hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684     if (device_param->skipped) continue;
1685
1686     speed_cnt[device_id] = device_param->speed_cnt[0];
1687     speed_ms[device_id]  = device_param->speed_ms[0];
1688   }
1689
1690   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1691
1692   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693   {
1694     hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696     if (device_param->skipped) continue;
1697
1698     hashes_dev_ms[device_id] = 0;
1699
1700     if (speed_ms[device_id])
1701     {
1702       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1703     }
1704   }
1705
1706   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1707   {
1708     hc_device_param_t *device_param = &data.devices_param[device_id];
1709
1710     if (device_param->skipped) continue;
1711
1712     log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1713   }
1714 }
1715
1716 static void status_benchmark ()
1717 {
1718   if (data.devices_status == STATUS_INIT)     return;
1719   if (data.devices_status == STATUS_STARTING) return;
1720
1721   if (data.shutdown_inner == 1) return;
1722
1723   if (data.machine_readable == 1)
1724   {
1725     status_benchmark_automate ();
1726
1727     return;
1728   }
1729
1730   u64    speed_cnt[DEVICES_MAX] = { 0 };
1731   double speed_ms[DEVICES_MAX]  = { 0 };
1732
1733   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734   {
1735     hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737     if (device_param->skipped) continue;
1738
1739     speed_cnt[device_id] = device_param->speed_cnt[0];
1740     speed_ms[device_id]  = device_param->speed_ms[0];
1741   }
1742
1743   double hashes_all_ms = 0;
1744
1745   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1746
1747   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1748   {
1749     hc_device_param_t *device_param = &data.devices_param[device_id];
1750
1751     if (device_param->skipped) continue;
1752
1753     hashes_dev_ms[device_id] = 0;
1754
1755     if (speed_ms[device_id])
1756     {
1757       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1758
1759       hashes_all_ms += hashes_dev_ms[device_id];
1760     }
1761   }
1762
1763   /**
1764    * exec time
1765    */
1766
1767   double exec_all_ms[DEVICES_MAX] = { 0 };
1768
1769   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1770   {
1771     hc_device_param_t *device_param = &data.devices_param[device_id];
1772
1773     if (device_param->skipped) continue;
1774
1775     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1776
1777     exec_all_ms[device_id] = exec_ms_avg;
1778   }
1779
1780   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1781   {
1782     hc_device_param_t *device_param = &data.devices_param[device_id];
1783
1784     if (device_param->skipped) continue;
1785
1786     char display_dev_cur[16] = { 0 };
1787
1788     strncpy (display_dev_cur, "0.00", 4);
1789
1790     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1791
1792     if (data.devices_active >= 10)
1793     {
1794       log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1795     }
1796     else
1797     {
1798       log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799     }
1800   }
1801
1802   char display_all_cur[16] = { 0 };
1803
1804   strncpy (display_all_cur, "0.00", 4);
1805
1806   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1807
1808   if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1809 }
1810
1811 /**
1812  * hashcat -only- functions
1813  */
1814
1815 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1816 {
1817   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1818   {
1819     if (attack_kern == ATTACK_KERN_STRAIGHT)
1820       snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1821     else if (attack_kern == ATTACK_KERN_COMBI)
1822       snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1823     else if (attack_kern == ATTACK_KERN_BF)
1824       snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1825   }
1826   else
1827     snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1828 }
1829
1830 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)
1831 {
1832   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1833   {
1834     if (attack_kern == ATTACK_KERN_STRAIGHT)
1835       snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1836     else if (attack_kern == ATTACK_KERN_COMBI)
1837       snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1838     else if (attack_kern == ATTACK_KERN_BF)
1839       snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840   }
1841   else
1842   {
1843     snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844   }
1845 }
1846
1847 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1848 {
1849   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1850   {
1851     snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1852   }
1853   else
1854   {
1855     snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1856   }
1857 }
1858
1859 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)
1860 {
1861   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1862   {
1863     snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1864   }
1865   else
1866   {
1867     snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1868   }
1869 }
1870
1871 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1872 {
1873   snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1874 }
1875
1876 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1877 {
1878   snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1879 }
1880
1881 static char *filename_from_filepath (char *filepath)
1882 {
1883   char *ptr = NULL;
1884
1885   if ((ptr = strrchr (filepath, '/')) != NULL)
1886   {
1887     ptr++;
1888   }
1889   else if ((ptr = strrchr (filepath, '\\')) != NULL)
1890   {
1891     ptr++;
1892   }
1893   else
1894   {
1895     ptr = filepath;
1896   }
1897
1898   return ptr;
1899 }
1900
1901 static uint convert_from_hex (char *line_buf, const uint line_len)
1902 {
1903   if (line_len & 1) return (line_len); // not in hex
1904
1905   if (data.hex_wordlist == 1)
1906   {
1907     uint i;
1908     uint j;
1909
1910     for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1911     {
1912       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1913     }
1914
1915     memset (line_buf + i, 0, line_len - i);
1916
1917     return (i);
1918   }
1919   else if (line_len >= 6) // $HEX[] = 6
1920   {
1921     if (line_buf[0]            != '$') return (line_len);
1922     if (line_buf[1]            != 'H') return (line_len);
1923     if (line_buf[2]            != 'E') return (line_len);
1924     if (line_buf[3]            != 'X') return (line_len);
1925     if (line_buf[4]            != '[') return (line_len);
1926     if (line_buf[line_len - 1] != ']') return (line_len);
1927
1928     uint i;
1929     uint j;
1930
1931     for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1932     {
1933       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1934     }
1935
1936     memset (line_buf + i, 0, line_len - i);
1937
1938     return (i);
1939   }
1940
1941   return (line_len);
1942 }
1943
1944 static void clear_prompt ()
1945 {
1946   fputc ('\r', stdout);
1947
1948   for (size_t i = 0; i < strlen (PROMPT); i++)
1949   {
1950     fputc (' ', stdout);
1951   }
1952
1953   fputc ('\r', stdout);
1954
1955   fflush (stdout);
1956 }
1957
1958 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1959 {
1960   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);
1961 }
1962
1963 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1964 {
1965   char *outfile    = data.outfile;
1966   uint  quiet      = data.quiet;
1967   FILE *pot_fp     = data.pot_fp;
1968   uint  loopback   = data.loopback;
1969   uint  debug_mode = data.debug_mode;
1970   char *debug_file = data.debug_file;
1971
1972   char debug_rule_buf[BLOCK_SIZE] = { 0 };
1973   int  debug_rule_len  = 0; // -1 error
1974   uint debug_plain_len = 0;
1975
1976   u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1977
1978   // hash
1979
1980   char out_buf[HCBUFSIZ] = { 0 };
1981
1982   const u32 salt_pos    = plain->salt_pos;
1983   const u32 digest_pos  = plain->digest_pos;  // relative
1984   const u32 gidvid      = plain->gidvid;
1985   const u32 il_pos      = plain->il_pos;
1986
1987   ascii_digest (out_buf, salt_pos, digest_pos);
1988
1989   // plain
1990
1991   u64 crackpos = device_param->words_off;
1992
1993   uint plain_buf[16] = { 0 };
1994
1995   u8 *plain_ptr = (u8 *) plain_buf;
1996
1997   unsigned int plain_len = 0;
1998
1999   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2000   {
2001     pw_t pw;
2002
2003     gidd_to_pw_t (device_param, gidvid, &pw);
2004
2005     for (int i = 0; i < 16; i++)
2006     {
2007       plain_buf[i] = pw.i[i];
2008     }
2009
2010     plain_len = pw.pw_len;
2011
2012     const uint off = device_param->innerloop_pos + il_pos;
2013
2014     if (debug_mode > 0)
2015     {
2016       debug_rule_len = 0;
2017
2018       // save rule
2019       if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2020       {
2021         memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2022
2023         debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2024       }
2025
2026       // save plain
2027       if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2028       {
2029         memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2030
2031         memcpy (debug_plain_ptr, plain_ptr, plain_len);
2032
2033         debug_plain_len = plain_len;
2034       }
2035     }
2036
2037     plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2038
2039     crackpos += gidvid;
2040     crackpos *= data.kernel_rules_cnt;
2041     crackpos += device_param->innerloop_pos + il_pos;
2042
2043     if (plain_len > data.pw_max) plain_len = data.pw_max;
2044   }
2045   else if (data.attack_mode == ATTACK_MODE_COMBI)
2046   {
2047     pw_t pw;
2048
2049     gidd_to_pw_t (device_param, gidvid, &pw);
2050
2051     for (int i = 0; i < 16; i++)
2052     {
2053       plain_buf[i] = pw.i[i];
2054     }
2055
2056     plain_len = pw.pw_len;
2057
2058     char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2059     uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2060
2061     if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2062     {
2063       memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2064     }
2065     else
2066     {
2067       memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2068
2069       memcpy (plain_ptr, comb_buf, comb_len);
2070     }
2071
2072     plain_len += comb_len;
2073
2074     crackpos += gidvid;
2075     crackpos *= data.combs_cnt;
2076     crackpos += device_param->innerloop_pos + il_pos;
2077
2078     if (data.pw_max != PW_DICTMAX1)
2079     {
2080       if (plain_len > data.pw_max) plain_len = data.pw_max;
2081     }
2082   }
2083   else if (data.attack_mode == ATTACK_MODE_BF)
2084   {
2085     u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2086     u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2087
2088     uint l_start = device_param->kernel_params_mp_l_buf32[5];
2089     uint r_start = device_param->kernel_params_mp_r_buf32[5];
2090
2091     uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2092     uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2093
2094     sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2095     sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2096
2097     plain_len = data.css_cnt;
2098
2099     crackpos += gidvid;
2100     crackpos *= data.bfs_cnt;
2101     crackpos += device_param->innerloop_pos + il_pos;
2102   }
2103   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2104   {
2105     pw_t pw;
2106
2107     gidd_to_pw_t (device_param, gidvid, &pw);
2108
2109     for (int i = 0; i < 16; i++)
2110     {
2111       plain_buf[i] = pw.i[i];
2112     }
2113
2114     plain_len = pw.pw_len;
2115
2116     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2117
2118     uint start = 0;
2119     uint stop  = device_param->kernel_params_mp_buf32[4];
2120
2121     sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2122
2123     plain_len += start + stop;
2124
2125     crackpos += gidvid;
2126     crackpos *= data.combs_cnt;
2127     crackpos += device_param->innerloop_pos + il_pos;
2128
2129     if (data.pw_max != PW_DICTMAX1)
2130     {
2131       if (plain_len > data.pw_max) plain_len = data.pw_max;
2132     }
2133   }
2134   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2135   {
2136     pw_t pw;
2137
2138     gidd_to_pw_t (device_param, gidvid, &pw);
2139
2140     for (int i = 0; i < 16; i++)
2141     {
2142       plain_buf[i] = pw.i[i];
2143     }
2144
2145     plain_len = pw.pw_len;
2146
2147     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2148
2149     uint start = 0;
2150     uint stop  = device_param->kernel_params_mp_buf32[4];
2151
2152     memmove (plain_ptr + stop, plain_ptr, plain_len);
2153
2154     sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2155
2156     plain_len += start + stop;
2157
2158     crackpos += gidvid;
2159     crackpos *= data.combs_cnt;
2160     crackpos += device_param->innerloop_pos + il_pos;
2161
2162     if (data.pw_max != PW_DICTMAX1)
2163     {
2164       if (plain_len > data.pw_max) plain_len = data.pw_max;
2165     }
2166   }
2167
2168   if (data.attack_mode == ATTACK_MODE_BF)
2169   {
2170     if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2171     {
2172       if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2173       {
2174         if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2175         {
2176           plain_len = plain_len - data.salts_buf[0].salt_len;
2177         }
2178       }
2179
2180       if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2181       {
2182         for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2183         {
2184           plain_ptr[j] = plain_ptr[i];
2185         }
2186
2187         plain_len = plain_len / 2;
2188       }
2189     }
2190   }
2191
2192   // if enabled, update also the potfile
2193
2194   if (pot_fp)
2195   {
2196     lock_file (pot_fp);
2197
2198     fprintf (pot_fp, "%s:", out_buf);
2199
2200     format_plain (pot_fp, plain_ptr, plain_len, 1);
2201
2202     fputc ('\n', pot_fp);
2203
2204     fflush (pot_fp);
2205
2206     unlock_file (pot_fp);
2207   }
2208
2209   // outfile
2210
2211   FILE *out_fp = NULL;
2212
2213   if (outfile != NULL)
2214   {
2215     if ((out_fp = fopen (outfile, "ab")) == NULL)
2216     {
2217       log_error ("ERROR: %s: %s", outfile, strerror (errno));
2218
2219       out_fp = stdout;
2220     }
2221
2222     lock_file (out_fp);
2223   }
2224   else
2225   {
2226     out_fp = stdout;
2227
2228     if (quiet == 0) clear_prompt ();
2229   }
2230
2231   format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2232
2233   if (outfile != NULL)
2234   {
2235     if (out_fp != stdout)
2236     {
2237       fclose (out_fp);
2238     }
2239   }
2240   else
2241   {
2242     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2243     {
2244       if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2245       {
2246         if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2247         if (quiet == 0) fflush (stdout);
2248       }
2249     }
2250   }
2251
2252   // loopback
2253
2254   if (loopback)
2255   {
2256     char *loopback_file = data.loopback_file;
2257
2258     FILE *fb_fp = NULL;
2259
2260     if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2261     {
2262       lock_file (fb_fp);
2263
2264       format_plain (fb_fp, plain_ptr, plain_len, 1);
2265
2266       fputc ('\n', fb_fp);
2267
2268       fclose (fb_fp);
2269     }
2270   }
2271
2272   // (rule) debug mode
2273
2274   // the next check implies that:
2275   // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2276   // - debug_mode > 0
2277
2278   if ((debug_plain_len > 0) || (debug_rule_len > 0))
2279   {
2280     if (debug_rule_len < 0) debug_rule_len = 0;
2281
2282     if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2283
2284     format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2285
2286     if ((quiet == 0) && (debug_file == NULL))
2287     {
2288       fprintf (stdout, "%s", PROMPT);
2289
2290       fflush (stdout);
2291     }
2292   }
2293 }
2294
2295 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2296 {
2297   salt_t *salt_buf = &data.salts_buf[salt_pos];
2298
2299   u32 num_cracked;
2300
2301   hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2302
2303   if (num_cracked)
2304   {
2305     // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2306
2307     log_info_nn ("");
2308
2309     plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2310
2311     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);
2312
2313     uint cpt_cracked = 0;
2314
2315     hc_thread_mutex_lock (mux_display);
2316
2317     for (uint i = 0; i < num_cracked; i++)
2318     {
2319       const uint hash_pos = cracked[i].hash_pos;
2320
2321       if (data.digests_shown[hash_pos] == 1) continue;
2322
2323       if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2324       {
2325         data.digests_shown[hash_pos] = 1;
2326
2327         data.digests_done++;
2328
2329         cpt_cracked++;
2330
2331         salt_buf->digests_done++;
2332
2333         if (salt_buf->digests_done == salt_buf->digests_cnt)
2334         {
2335           data.salts_shown[salt_pos] = 1;
2336
2337           data.salts_done++;
2338         }
2339       }
2340
2341       if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2342
2343       check_hash (device_param, &cracked[i]);
2344     }
2345
2346     hc_thread_mutex_unlock (mux_display);
2347
2348     myfree (cracked);
2349
2350     if (cpt_cracked > 0)
2351     {
2352       hc_thread_mutex_lock (mux_display);
2353
2354       data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2355       data.cpt_buf[data.cpt_pos].cracked   = cpt_cracked;
2356
2357       data.cpt_pos++;
2358
2359       data.cpt_total += cpt_cracked;
2360
2361       if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2362
2363       hc_thread_mutex_unlock (mux_display);
2364     }
2365
2366     if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2367     {
2368       // we need to reset cracked state on the device
2369       // otherwise host thinks again and again the hash was cracked
2370       // and returns invalid password each time
2371
2372       memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2373
2374       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);
2375     }
2376
2377     num_cracked = 0;
2378
2379     hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2380   }
2381 }
2382
2383 // stolen from princeprocessor ;)
2384
2385 typedef struct
2386 {
2387   FILE *fp;
2388
2389   char  buf[BUFSIZ];
2390   int   len;
2391
2392 } out_t;
2393
2394 static void out_flush (out_t *out)
2395 {
2396   fwrite (out->buf, 1, out->len, out->fp);
2397
2398   out->len = 0;
2399 }
2400
2401 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2402 {
2403   char *ptr = out->buf + out->len;
2404
2405   memcpy (ptr, pw_buf, pw_len);
2406
2407   ptr[pw_len] = '\n';
2408
2409   out->len += pw_len + 1;
2410
2411   if (out->len >= BUFSIZ - 100)
2412   {
2413     out_flush (out);
2414   }
2415 }
2416
2417 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2418 {
2419   out_t out;
2420
2421   out.fp  = stdout;
2422   out.len = 0;
2423
2424   uint plain_buf[16] = { 0 };
2425
2426   u8 *plain_ptr = (u8 *) plain_buf;
2427
2428   uint plain_len = 0;
2429
2430   const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2431
2432   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2433   {
2434     pw_t pw;
2435
2436     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2437     {
2438       gidd_to_pw_t (device_param, gidvid, &pw);
2439
2440       const uint pos = device_param->innerloop_pos;
2441
2442       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2443       {
2444         for (int i = 0; i < 8; i++)
2445         {
2446           plain_buf[i] = pw.i[i];
2447         }
2448
2449         plain_len = pw.pw_len;
2450
2451         plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2452
2453         if (plain_len > data.pw_max) plain_len = data.pw_max;
2454
2455         out_push (&out, plain_ptr, plain_len);
2456       }
2457     }
2458   }
2459   else if (data.attack_mode == ATTACK_MODE_COMBI)
2460   {
2461     pw_t pw;
2462
2463     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2464     {
2465       gidd_to_pw_t (device_param, gidvid, &pw);
2466
2467       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2468       {
2469         for (int i = 0; i < 8; i++)
2470         {
2471           plain_buf[i] = pw.i[i];
2472         }
2473
2474         plain_len = pw.pw_len;
2475
2476         char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2477         uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2478
2479         if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2480         {
2481           memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2482         }
2483         else
2484         {
2485           memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2486
2487           memcpy (plain_ptr, comb_buf, comb_len);
2488         }
2489
2490         plain_len += comb_len;
2491
2492         if (data.pw_max != PW_DICTMAX1)
2493         {
2494           if (plain_len > data.pw_max) plain_len = data.pw_max;
2495         }
2496
2497         out_push (&out, plain_ptr, plain_len);
2498       }
2499     }
2500   }
2501   else if (data.attack_mode == ATTACK_MODE_BF)
2502   {
2503     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2504     {
2505       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2506       {
2507         u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2508         u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2509
2510         uint l_start = device_param->kernel_params_mp_l_buf32[5];
2511         uint r_start = device_param->kernel_params_mp_r_buf32[5];
2512
2513         uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2514         uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2515
2516         sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2517         sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2518
2519         plain_len = data.css_cnt;
2520
2521         out_push (&out, plain_ptr, plain_len);
2522       }
2523     }
2524   }
2525   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2526   {
2527     pw_t pw;
2528
2529     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2530     {
2531       gidd_to_pw_t (device_param, gidvid, &pw);
2532
2533       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2534       {
2535         for (int i = 0; i < 8; i++)
2536         {
2537           plain_buf[i] = pw.i[i];
2538         }
2539
2540         plain_len = pw.pw_len;
2541
2542         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2543
2544         uint start = 0;
2545         uint stop  = device_param->kernel_params_mp_buf32[4];
2546
2547         sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2548
2549         plain_len += start + stop;
2550
2551         out_push (&out, plain_ptr, plain_len);
2552       }
2553     }
2554   }
2555   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2556   {
2557     pw_t pw;
2558
2559     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2560     {
2561       gidd_to_pw_t (device_param, gidvid, &pw);
2562
2563       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2564       {
2565         for (int i = 0; i < 8; i++)
2566         {
2567           plain_buf[i] = pw.i[i];
2568         }
2569
2570         plain_len = pw.pw_len;
2571
2572         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2573
2574         uint start = 0;
2575         uint stop  = device_param->kernel_params_mp_buf32[4];
2576
2577         memmove (plain_ptr + stop, plain_ptr, plain_len);
2578
2579         sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2580
2581         plain_len += start + stop;
2582
2583         out_push (&out, plain_ptr, plain_len);
2584       }
2585     }
2586   }
2587
2588   out_flush (&out);
2589 }
2590
2591 static void save_hash ()
2592 {
2593   char *hashfile = data.hashfile;
2594
2595   char new_hashfile[256] = { 0 };
2596   char old_hashfile[256] = { 0 };
2597
2598   snprintf (new_hashfile, 255, "%s.new", hashfile);
2599   snprintf (old_hashfile, 255, "%s.old", hashfile);
2600
2601   unlink (new_hashfile);
2602
2603   char separator = data.separator;
2604
2605   FILE *fp = fopen (new_hashfile, "wb");
2606
2607   if (fp == NULL)
2608   {
2609     log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2610
2611     exit (-1);
2612   }
2613
2614   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2615   {
2616     if (data.salts_shown[salt_pos] == 1) continue;
2617
2618     salt_t *salt_buf = &data.salts_buf[salt_pos];
2619
2620     for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2621     {
2622       uint idx = salt_buf->digests_offset + digest_pos;
2623
2624       if (data.digests_shown[idx] == 1) continue;
2625
2626       if (data.hash_mode != 2500)
2627       {
2628         if (data.username == 1)
2629         {
2630           user_t *user = data.hash_info[idx]->user;
2631
2632           uint i;
2633
2634           for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2635
2636           fputc (separator, fp);
2637         }
2638
2639         char out_buf[HCBUFSIZ]; // scratch buffer
2640
2641         out_buf[0] = 0;
2642
2643         ascii_digest (out_buf, salt_pos, digest_pos);
2644
2645         fputs (out_buf, fp);
2646
2647         fputc ('\n', fp);
2648       }
2649       else
2650       {
2651         hccap_t hccap;
2652
2653         to_hccap_t (&hccap, salt_pos, digest_pos);
2654
2655         fwrite (&hccap, sizeof (hccap_t), 1, fp);
2656       }
2657     }
2658   }
2659
2660   fflush (fp);
2661
2662   fclose (fp);
2663
2664   unlink (old_hashfile);
2665
2666   if (rename (hashfile, old_hashfile) != 0)
2667   {
2668     log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2669
2670     exit (-1);
2671   }
2672
2673   unlink (hashfile);
2674
2675   if (rename (new_hashfile, hashfile) != 0)
2676   {
2677     log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2678
2679     exit (-1);
2680   }
2681
2682   unlink (old_hashfile);
2683 }
2684
2685 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2686 {
2687   uint num_elements = num;
2688
2689   device_param->kernel_params_buf32[33] = data.combs_mode;
2690   device_param->kernel_params_buf32[34] = num;
2691
2692   uint kernel_threads = device_param->kernel_threads;
2693
2694   while (num_elements % kernel_threads) num_elements++;
2695
2696   cl_kernel kernel = NULL;
2697
2698   switch (kern_run)
2699   {
2700     case KERN_RUN_1:    kernel = device_param->kernel1;     break;
2701     case KERN_RUN_12:   kernel = device_param->kernel12;    break;
2702     case KERN_RUN_2:    kernel = device_param->kernel2;     break;
2703     case KERN_RUN_23:   kernel = device_param->kernel23;    break;
2704     case KERN_RUN_3:    kernel = device_param->kernel3;     break;
2705   }
2706
2707   hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2708   hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2709   hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2710   hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2711   hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2712   hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2713   hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2714   hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2715   hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2716   hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2717   hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2718
2719   cl_event event;
2720
2721   if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2722   {
2723     const size_t global_work_size[3] = { num_elements,        32, 1 };
2724     const size_t local_work_size[3]  = { kernel_threads / 32, 32, 1 };
2725
2726     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2727   }
2728   else
2729   {
2730     if (kern_run == KERN_RUN_2)
2731     {
2732       if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2733       {
2734         num_elements = CEIL ((float) num_elements / device_param->vector_width);
2735       }
2736     }
2737
2738     while (num_elements % kernel_threads) num_elements++;
2739
2740     const size_t global_work_size[3] = { num_elements,   1, 1 };
2741     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2742
2743     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2744   }
2745
2746   hc_clFlush (data.ocl, device_param->command_queue);
2747
2748   if (device_param->nvidia_spin_damp)
2749   {
2750     if (data.devices_status == STATUS_RUNNING)
2751     {
2752       if (iteration < EXPECTED_ITERATIONS)
2753       {
2754         switch (kern_run)
2755         {
2756           case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2757           case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2758           case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2759         }
2760       }
2761     }
2762   }
2763
2764   hc_clWaitForEvents (data.ocl, 1, &event);
2765
2766   cl_ulong time_start;
2767   cl_ulong time_end;
2768
2769   hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2770   hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END,   sizeof (time_end),   &time_end,   NULL);
2771
2772   const double exec_us = (double) (time_end - time_start) / 1000;
2773
2774   if (data.devices_status == STATUS_RUNNING)
2775   {
2776     if (iteration < EXPECTED_ITERATIONS)
2777     {
2778       switch (kern_run)
2779       {
2780         case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2781         case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2782         case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2783       }
2784     }
2785   }
2786
2787   if (event_update)
2788   {
2789     uint exec_pos = device_param->exec_pos;
2790
2791     device_param->exec_ms[exec_pos] = exec_us / 1000;
2792
2793     exec_pos++;
2794
2795     if (exec_pos == EXEC_CACHE)
2796     {
2797       exec_pos = 0;
2798     }
2799
2800     device_param->exec_pos = exec_pos;
2801   }
2802
2803   hc_clReleaseEvent (data.ocl, event);
2804
2805   hc_clFinish (data.ocl, device_param->command_queue);
2806 }
2807
2808 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2809 {
2810   uint num_elements = num;
2811
2812   switch (kern_run)
2813   {
2814     case KERN_RUN_MP:   device_param->kernel_params_mp_buf32[8]   = num; break;
2815     case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2816     case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2817   }
2818
2819   // causes problems with special threads like in bcrypt
2820   // const uint kernel_threads = device_param->kernel_threads;
2821
2822   uint kernel_threads = device_param->kernel_threads;
2823
2824   while (num_elements % kernel_threads) num_elements++;
2825
2826   cl_kernel kernel = NULL;
2827
2828   switch (kern_run)
2829   {
2830     case KERN_RUN_MP:   kernel = device_param->kernel_mp;   break;
2831     case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2832     case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2833   }
2834
2835   switch (kern_run)
2836   {
2837     case KERN_RUN_MP:   hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2838                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp[4]);
2839                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp[5]);
2840                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp[6]);
2841                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp[7]);
2842                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp[8]);
2843                         break;
2844     case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2845                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_r[4]);
2846                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_r[5]);
2847                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_r[6]);
2848                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_r[7]);
2849                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_r[8]);
2850                         break;
2851     case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2852                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_l[4]);
2853                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_l[5]);
2854                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_l[6]);
2855                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_l[7]);
2856                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_l[8]);
2857                         hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint),  device_param->kernel_params_mp_l[9]);
2858                         break;
2859   }
2860
2861   const size_t global_work_size[3] = { num_elements,   1, 1 };
2862   const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2863
2864   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2865
2866   hc_clFlush (data.ocl, device_param->command_queue);
2867
2868   hc_clFinish (data.ocl, device_param->command_queue);
2869 }
2870
2871 static void run_kernel_tm (hc_device_param_t *device_param)
2872 {
2873   const uint num_elements = 1024; // fixed
2874
2875   uint kernel_threads = 32;
2876
2877   cl_kernel kernel = device_param->kernel_tm;
2878
2879   const size_t global_work_size[3] = { num_elements,    1, 1 };
2880   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
2881
2882   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884   hc_clFlush (data.ocl, device_param->command_queue);
2885
2886   hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2890 {
2891   uint num_elements = num;
2892
2893   device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2894   device_param->kernel_params_amp_buf32[6] = num_elements;
2895
2896   // causes problems with special threads like in bcrypt
2897   // const uint kernel_threads = device_param->kernel_threads;
2898
2899   uint kernel_threads = device_param->kernel_threads;
2900
2901   while (num_elements % kernel_threads) num_elements++;
2902
2903   cl_kernel kernel = device_param->kernel_amp;
2904
2905   hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2906   hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2907
2908   const size_t global_work_size[3] = { num_elements,    1, 1 };
2909   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
2910
2911   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2912
2913   hc_clFlush (data.ocl, device_param->command_queue);
2914
2915   hc_clFinish (data.ocl, device_param->command_queue);
2916 }
2917
2918 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2919 {
2920   const u32 num16d = num / 16;
2921   const u32 num16m = num % 16;
2922
2923   if (num16d)
2924   {
2925     device_param->kernel_params_memset_buf32[1] = value;
2926     device_param->kernel_params_memset_buf32[2] = num16d;
2927
2928     uint kernel_threads = device_param->kernel_threads;
2929
2930     uint num_elements = num16d;
2931
2932     while (num_elements % kernel_threads) num_elements++;
2933
2934     cl_kernel kernel = device_param->kernel_memset;
2935
2936     hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem),  (void *) &buf);
2937     hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2938     hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2939
2940     const size_t global_work_size[3] = { num_elements,   1, 1 };
2941     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2942
2943     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2944
2945     hc_clFlush (data.ocl, device_param->command_queue);
2946
2947     hc_clFinish (data.ocl, device_param->command_queue);
2948   }
2949
2950   if (num16m)
2951   {
2952     u32 tmp[4];
2953
2954     tmp[0] = value;
2955     tmp[1] = value;
2956     tmp[2] = value;
2957     tmp[3] = value;
2958
2959     hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2960   }
2961 }
2962
2963 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2964 {
2965   run_kernel_memset (device_param, buf, 0, size);
2966
2967   /*
2968   int rc = -1;
2969
2970   if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2971   {
2972     // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2973
2974     const cl_uchar zero = 0;
2975
2976     rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2977   }
2978
2979   if (rc != 0)
2980   {
2981     // NOTE: clEnqueueFillBuffer () always fails with -59
2982     //       IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2983     //       How's that possible, OpenCL 1.2 support is advertised??
2984     //       We need to workaround...
2985
2986     #define FILLSZ 0x100000
2987
2988     char *tmp = (char *) mymalloc (FILLSZ);
2989
2990     for (size_t i = 0; i < size; i += FILLSZ)
2991     {
2992       const size_t left = size - i;
2993
2994       const size_t fillsz = MIN (FILLSZ, left);
2995
2996       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2997     }
2998
2999     myfree (tmp);
3000   }
3001   */
3002 }
3003
3004 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, const uint fast_iteration)
3005 {
3006   if (data.hash_mode == 2000)
3007   {
3008     process_stdout (device_param, pws_cnt);
3009
3010     return;
3011   }
3012
3013   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3014   {
3015     if (attack_mode == ATTACK_MODE_BF)
3016     {
3017       if (opts_type & OPTS_TYPE_PT_BITSLICE)
3018       {
3019         const uint size_tm = 32 * sizeof (bs_word_t);
3020
3021         run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3022
3023         run_kernel_tm (device_param);
3024
3025         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);
3026       }
3027     }
3028
3029     if (highest_pw_len < 16)
3030     {
3031       run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3032     }
3033     else if (highest_pw_len < 32)
3034     {
3035       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3036     }
3037     else
3038     {
3039       run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3040     }
3041   }
3042   else
3043   {
3044     run_kernel_amp (device_param, pws_cnt);
3045
3046     run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3047
3048     if (opts_type & OPTS_TYPE_HOOK12)
3049     {
3050       run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3051
3052       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);
3053
3054       // do something with data
3055
3056       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);
3057     }
3058
3059     uint iter = salt_buf->salt_iter;
3060
3061     uint loop_step = device_param->kernel_loops;
3062
3063     for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3064     {
3065       uint loop_left = iter - loop_pos;
3066
3067       loop_left = MIN (loop_left, loop_step);
3068
3069       device_param->kernel_params_buf32[28] = loop_pos;
3070       device_param->kernel_params_buf32[29] = loop_left;
3071
3072       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3073
3074       if (data.devices_status == STATUS_CRACKED) break;
3075       if (data.devices_status == STATUS_ABORTED) break;
3076       if (data.devices_status == STATUS_QUIT)    break;
3077       if (data.devices_status == STATUS_BYPASS)  break;
3078
3079       /**
3080        * speed
3081        */
3082
3083       const float iter_part = (float) (loop_pos + loop_left) / iter;
3084
3085       const u64 perf_sum_all = pws_cnt * iter_part;
3086
3087       double speed_ms;
3088
3089       hc_timer_get (device_param->timer_speed, speed_ms);
3090
3091       const u32 speed_pos = device_param->speed_pos;
3092
3093       device_param->speed_cnt[speed_pos] = perf_sum_all;
3094
3095       device_param->speed_ms[speed_pos] = speed_ms;
3096
3097       if (data.benchmark == 1)
3098       {
3099         if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3100       }
3101     }
3102
3103     if (opts_type & OPTS_TYPE_HOOK23)
3104     {
3105       run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3106
3107       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);
3108
3109       // do something with data
3110
3111       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);
3112     }
3113
3114     run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3115   }
3116 }
3117
3118 static int run_rule_engine (const int rule_len, const char *rule_buf)
3119 {
3120   if (rule_len == 0)
3121   {
3122     return 0;
3123   }
3124   else if (rule_len == 1)
3125   {
3126     if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3127   }
3128
3129   return 1;
3130 }
3131
3132 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3133 {
3134   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3135   {
3136     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);
3137   }
3138   else if (data.attack_kern == ATTACK_KERN_COMBI)
3139   {
3140     if (data.attack_mode == ATTACK_MODE_COMBI)
3141     {
3142       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3143       {
3144         if (data.opts_type & OPTS_TYPE_PT_ADD01)
3145         {
3146           for (u32 i = 0; i < pws_cnt; i++)
3147           {
3148             const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152             ptr[pw_len] = 0x01;
3153           }
3154         }
3155         else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3156         {
3157           for (u32 i = 0; i < pws_cnt; i++)
3158           {
3159             const u32 pw_len = device_param->pws_buf[i].pw_len;
3160
3161             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3162
3163             ptr[pw_len] = 0x80;
3164           }
3165         }
3166       }
3167     }
3168     else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3169     {
3170       if (data.opts_type & OPTS_TYPE_PT_ADD01)
3171       {
3172         for (u32 i = 0; i < pws_cnt; i++)
3173         {
3174           const u32 pw_len = device_param->pws_buf[i].pw_len;
3175
3176           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3177
3178           ptr[pw_len] = 0x01;
3179         }
3180       }
3181       else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3182       {
3183         for (u32 i = 0; i < pws_cnt; i++)
3184         {
3185           const u32 pw_len = device_param->pws_buf[i].pw_len;
3186
3187           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3188
3189           ptr[pw_len] = 0x80;
3190         }
3191       }
3192     }
3193
3194     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);
3195   }
3196   else if (data.attack_kern == ATTACK_KERN_BF)
3197   {
3198     const u64 off = device_param->words_off;
3199
3200     device_param->kernel_params_mp_l_buf64[3] = off;
3201
3202     run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3203   }
3204 }
3205
3206 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3207 {
3208   const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3209
3210   device_param->kernel_params_buf32[28] = 0;
3211   device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3212   device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3213
3214   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3215   {
3216     run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3217   }
3218   else
3219   {
3220     run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3221   }
3222
3223   const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3224
3225   return exec_ms_prev;
3226 }
3227
3228 static void autotune (hc_device_param_t *device_param)
3229 {
3230   const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3231
3232   const u32 kernel_accel_min = device_param->kernel_accel_min;
3233   const u32 kernel_accel_max = device_param->kernel_accel_max;
3234
3235   const u32 kernel_loops_min = device_param->kernel_loops_min;
3236   const u32 kernel_loops_max = device_param->kernel_loops_max;
3237
3238   u32 kernel_accel = kernel_accel_min;
3239   u32 kernel_loops = kernel_loops_min;
3240
3241   // in this case the user specified a fixed -u and -n on the commandline
3242   // no way to tune anything
3243   // but we need to run a few caching rounds
3244
3245   if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3246   {
3247     if (data.hash_mode != 2000)
3248     {
3249       try_run (device_param, kernel_accel, kernel_loops);
3250       try_run (device_param, kernel_accel, kernel_loops);
3251       try_run (device_param, kernel_accel, kernel_loops);
3252       try_run (device_param, kernel_accel, kernel_loops);
3253     }
3254
3255     device_param->kernel_accel = kernel_accel;
3256     device_param->kernel_loops = kernel_loops;
3257
3258     const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3259
3260     device_param->kernel_power = kernel_power;
3261
3262     return;
3263   }
3264
3265   // from here it's clear we are allowed to autotune
3266   // so let's init some fake words
3267
3268   const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3269
3270   if (data.attack_kern == ATTACK_KERN_BF)
3271   {
3272     run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3273   }
3274   else
3275   {
3276     for (u32 i = 0; i < kernel_power_max; i++)
3277     {
3278       device_param->pws_buf[i].i[0]   = i;
3279       device_param->pws_buf[i].i[1]   = 0x01234567;
3280       device_param->pws_buf[i].pw_len = 7 + (i & 7);
3281     }
3282
3283     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);
3284   }
3285
3286   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3287   {
3288     if (data.kernel_rules_cnt > 1)
3289     {
3290       hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3291     }
3292   }
3293   else
3294   {
3295     run_kernel_amp (device_param, kernel_power_max);
3296   }
3297
3298   #define VERIFIER_CNT 1
3299
3300   // first find out highest kernel-loops that stays below target_ms
3301
3302   if (kernel_loops_min < kernel_loops_max)
3303   {
3304     for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3305     {
3306       double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3307
3308       for (int i = 0; i < VERIFIER_CNT; i++)
3309       {
3310         double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3311
3312         exec_ms = MIN (exec_ms, exec_ms_v);
3313       }
3314
3315       if (exec_ms < target_ms) break;
3316     }
3317   }
3318
3319   // now the same for kernel-accel but with the new kernel-loops from previous loop set
3320
3321   #define STEPS_CNT 10
3322
3323   if (kernel_accel_min < kernel_accel_max)
3324   {
3325     for (int i = 0; i < STEPS_CNT; i++)
3326     {
3327       const u32 kernel_accel_try = 1 << i;
3328
3329       if (kernel_accel_try < kernel_accel_min) continue;
3330       if (kernel_accel_try > kernel_accel_max) break;
3331
3332       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3333
3334       for (int i = 0; i < VERIFIER_CNT; i++)
3335       {
3336         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3337
3338         exec_ms = MIN (exec_ms, exec_ms_v);
3339       }
3340
3341       if (exec_ms > target_ms) break;
3342
3343       kernel_accel = kernel_accel_try;
3344     }
3345   }
3346
3347   // at this point we want to know the actual runtime for the following reason:
3348   // we need a reference for the balancing loop following up, and this
3349   // the balancing loop can have an effect that the creates a new opportunity, for example:
3350   //   if the target is 95 ms and the current runtime is 48ms the above loop
3351   //   stopped the execution because the previous exec_ms was > 95ms
3352   //   due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3353   //   and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3354
3355   double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3356
3357   for (int i = 0; i < VERIFIER_CNT; i++)
3358   {
3359     double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3360
3361     exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3362   }
3363
3364   u32 diff = kernel_loops - kernel_accel;
3365
3366   if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3367   {
3368     u32 kernel_accel_orig = kernel_accel;
3369     u32 kernel_loops_orig = kernel_loops;
3370
3371     for (u32 f = 1; f < 1024; f++)
3372     {
3373       const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3374       const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3375
3376       if (kernel_accel_try > kernel_accel_max) break;
3377       if (kernel_loops_try < kernel_loops_min) break;
3378
3379       u32 diff_new = kernel_loops_try - kernel_accel_try;
3380
3381       if (diff_new > diff) break;
3382
3383       diff_new = diff;
3384
3385       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3386
3387       for (int i = 0; i < VERIFIER_CNT; i++)
3388       {
3389         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3390
3391         exec_ms = MIN (exec_ms, exec_ms_v);
3392       }
3393
3394       if (exec_ms < exec_ms_pre_final)
3395       {
3396         exec_ms_pre_final = exec_ms;
3397
3398         kernel_accel = kernel_accel_try;
3399         kernel_loops = kernel_loops_try;
3400       }
3401     }
3402   }
3403
3404   const double exec_left = target_ms / exec_ms_pre_final;
3405
3406   const double accel_left = kernel_accel_max / kernel_accel;
3407
3408   const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3409
3410   if (exec_accel_min >= 1.0)
3411   {
3412     // this is safe to not overflow kernel_accel_max because of accel_left
3413
3414     kernel_accel = (double) kernel_accel * exec_accel_min;
3415   }
3416
3417   // reset them fake words
3418
3419   /*
3420   memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3421
3422   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);
3423   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);
3424   */
3425
3426   run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3427
3428   if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3429   {
3430     run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3431   }
3432
3433   // reset timer
3434
3435   device_param->exec_pos = 0;
3436
3437   memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3438
3439   memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3440   memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3441   memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3442
3443   // store
3444
3445   device_param->kernel_accel = kernel_accel;
3446   device_param->kernel_loops = kernel_loops;
3447
3448   const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3449
3450   device_param->kernel_power = kernel_power;
3451
3452   #ifdef DEBUG
3453
3454   if (data.quiet == 0)
3455   {
3456     clear_prompt ();
3457
3458     log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3459               "- Device #%u: autotuned kernel-loops to %u\n",
3460               device_param->device_id + 1, kernel_accel,
3461               device_param->device_id + 1, kernel_loops);
3462
3463     fprintf (stdout, "%s", PROMPT);
3464
3465     fflush (stdout);
3466   }
3467
3468   #endif
3469 }
3470
3471 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3472 {
3473   char *line_buf = (char *) mymalloc (HCBUFSIZ);
3474
3475   // init speed timer
3476
3477   uint speed_pos = device_param->speed_pos;
3478
3479   #ifdef _POSIX
3480   if (device_param->timer_speed.tv_sec == 0)
3481   {
3482     hc_timer_set (&device_param->timer_speed);
3483   }
3484   #endif
3485
3486   #ifdef _WIN
3487   if (device_param->timer_speed.QuadPart == 0)
3488   {
3489     hc_timer_set (&device_param->timer_speed);
3490   }
3491   #endif
3492
3493   // find higest password length, this is for optimization stuff
3494
3495   uint highest_pw_len = 0;
3496
3497   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3498   {
3499   }
3500   else if (data.attack_kern == ATTACK_KERN_COMBI)
3501   {
3502   }
3503   else if (data.attack_kern == ATTACK_KERN_BF)
3504   {
3505     highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3506                    + device_param->kernel_params_mp_l_buf32[5];
3507   }
3508
3509   // iteration type
3510
3511   uint innerloop_step = 0;
3512   uint innerloop_cnt  = 0;
3513
3514   if      (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)   innerloop_step = device_param->kernel_loops;
3515   else                                                      innerloop_step = 1;
3516
3517   if      (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt  = data.kernel_rules_cnt;
3518   else if (data.attack_kern == ATTACK_KERN_COMBI)    innerloop_cnt  = data.combs_cnt;
3519   else if (data.attack_kern == ATTACK_KERN_BF)       innerloop_cnt  = data.bfs_cnt;
3520
3521   // loop start: most outer loop = salt iteration, then innerloops (if multi)
3522
3523   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3524   {
3525     while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3526
3527     if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3528
3529     if (data.devices_status == STATUS_CRACKED) break;
3530     if (data.devices_status == STATUS_ABORTED) break;
3531     if (data.devices_status == STATUS_QUIT)    break;
3532     if (data.devices_status == STATUS_BYPASS)  break;
3533
3534     salt_t *salt_buf = &data.salts_buf[salt_pos];
3535
3536     device_param->kernel_params_buf32[27] = salt_pos;
3537     device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3538     device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3539
3540     FILE *combs_fp = device_param->combs_fp;
3541
3542     if (data.attack_mode == ATTACK_MODE_COMBI)
3543     {
3544       rewind (combs_fp);
3545     }
3546
3547     // innerloops
3548
3549     for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3550     {
3551       while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3552
3553       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3554
3555       if (data.devices_status == STATUS_CRACKED) break;
3556       if (data.devices_status == STATUS_ABORTED) break;
3557       if (data.devices_status == STATUS_QUIT)    break;
3558       if (data.devices_status == STATUS_BYPASS)  break;
3559
3560       uint fast_iteration = 0;
3561
3562       uint innerloop_left = innerloop_cnt - innerloop_pos;
3563
3564       if (innerloop_left > innerloop_step)
3565       {
3566         innerloop_left = innerloop_step;
3567
3568         fast_iteration = 1;
3569       }
3570
3571       device_param->innerloop_pos  = innerloop_pos;
3572       device_param->innerloop_left = innerloop_left;
3573
3574       device_param->kernel_params_buf32[30] = innerloop_left;
3575
3576       // i think we can get rid of this
3577       if (innerloop_left == 0)
3578       {
3579         puts ("bug, how should this happen????\n");
3580
3581         continue;
3582       }
3583
3584       if (data.salts_shown[salt_pos] == 1)
3585       {
3586         data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3587
3588         continue;
3589       }
3590
3591       // initialize amplifiers
3592
3593       if (data.attack_mode == ATTACK_MODE_COMBI)
3594       {
3595         uint i = 0;
3596
3597         while (i < innerloop_left)
3598         {
3599           if (feof (combs_fp)) break;
3600
3601           int line_len = fgetl (combs_fp, line_buf);
3602
3603           if (line_len >= PW_MAX1) continue;
3604
3605           line_len = convert_from_hex (line_buf, line_len);
3606
3607           char *line_buf_new = line_buf;
3608
3609           if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3610           {
3611             char rule_buf_out[BLOCK_SIZE] = { 0 };
3612
3613             int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3614
3615             if (rule_len_out < 0)
3616             {
3617               data.words_progress_rejected[salt_pos] += pws_cnt;
3618
3619               continue;
3620             }
3621
3622             line_len = rule_len_out;
3623
3624             line_buf_new = rule_buf_out;
3625           }
3626
3627           line_len = MIN (line_len, PW_DICTMAX);
3628
3629           u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3630
3631           memcpy (ptr, line_buf_new, line_len);
3632
3633           memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3634
3635           if (data.opts_type & OPTS_TYPE_PT_UPPER)
3636           {
3637             uppercase (ptr, line_len);
3638           }
3639
3640           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3641           {
3642             if (data.opts_type & OPTS_TYPE_PT_ADD80)
3643             {
3644               ptr[line_len] = 0x80;
3645             }
3646
3647             if (data.opts_type & OPTS_TYPE_PT_ADD01)
3648             {
3649               ptr[line_len] = 0x01;
3650             }
3651           }
3652
3653           device_param->combs_buf[i].pw_len = line_len;
3654
3655           i++;
3656         }
3657
3658         for (uint j = i; j < innerloop_left; j++)
3659         {
3660           device_param->combs_buf[j].i[0] = 0;
3661           device_param->combs_buf[j].i[1] = 0;
3662           device_param->combs_buf[j].i[2] = 0;
3663           device_param->combs_buf[j].i[3] = 0;
3664           device_param->combs_buf[j].i[4] = 0;
3665           device_param->combs_buf[j].i[5] = 0;
3666           device_param->combs_buf[j].i[6] = 0;
3667           device_param->combs_buf[j].i[7] = 0;
3668
3669           device_param->combs_buf[j].pw_len = 0;
3670         }
3671
3672         innerloop_left = i;
3673       }
3674       else if (data.attack_mode == ATTACK_MODE_BF)
3675       {
3676         u64 off = innerloop_pos;
3677
3678         device_param->kernel_params_mp_r_buf64[3] = off;
3679
3680         run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3681       }
3682       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3683       {
3684         u64 off = innerloop_pos;
3685
3686         device_param->kernel_params_mp_buf64[3] = off;
3687
3688         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3689       }
3690       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3691       {
3692         u64 off = innerloop_pos;
3693
3694         device_param->kernel_params_mp_buf64[3] = off;
3695
3696         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3697       }
3698
3699       // copy amplifiers
3700
3701       if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3702       {
3703         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);
3704       }
3705       else if (data.attack_mode == ATTACK_MODE_COMBI)
3706       {
3707         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);
3708       }
3709       else if (data.attack_mode == ATTACK_MODE_BF)
3710       {
3711         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);
3712       }
3713       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3714       {
3715         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);
3716       }
3717       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3718       {
3719         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);
3720       }
3721
3722       if (data.benchmark == 1)
3723       {
3724         hc_timer_set (&device_param->timer_speed);
3725       }
3726
3727       choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3728
3729       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3730
3731       if (data.devices_status == STATUS_CRACKED) break;
3732       if (data.devices_status == STATUS_ABORTED) break;
3733       if (data.devices_status == STATUS_QUIT)    break;
3734       if (data.devices_status == STATUS_BYPASS)  break;
3735
3736       /**
3737        * result
3738        */
3739
3740       if (data.benchmark == 0)
3741       {
3742         check_cracked (device_param, salt_pos);
3743       }
3744
3745       /**
3746        * progress
3747        */
3748
3749       u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3750
3751       hc_thread_mutex_lock (mux_counter);
3752
3753       data.words_progress_done[salt_pos] += perf_sum_all;
3754
3755       hc_thread_mutex_unlock (mux_counter);
3756
3757       /**
3758        * speed
3759        */
3760
3761       double speed_ms;
3762
3763       hc_timer_get (device_param->timer_speed, speed_ms);
3764
3765       hc_timer_set (&device_param->timer_speed);
3766
3767       // current speed
3768
3769       //hc_thread_mutex_lock (mux_display);
3770
3771       device_param->speed_cnt[speed_pos] = perf_sum_all;
3772
3773       device_param->speed_ms[speed_pos] = speed_ms;
3774
3775       //hc_thread_mutex_unlock (mux_display);
3776
3777       speed_pos++;
3778
3779       if (speed_pos == SPEED_CACHE)
3780       {
3781         speed_pos = 0;
3782       }
3783
3784       /**
3785        * benchmark
3786        */
3787
3788       if (data.benchmark == 1) break;
3789     }
3790   }
3791
3792   device_param->speed_pos = speed_pos;
3793
3794   myfree (line_buf);
3795 }
3796
3797 static void load_segment (wl_data_t *wl_data, FILE *fd)
3798 {
3799   // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3800
3801   wl_data->pos = 0;
3802
3803   wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3804
3805   wl_data->buf[wl_data->cnt] = 0;
3806
3807   if (wl_data->cnt == 0) return;
3808
3809   if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3810
3811   while (!feof (fd))
3812   {
3813     if (wl_data->cnt == wl_data->avail)
3814     {
3815       wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3816
3817       wl_data->avail += wl_data->incr;
3818     }
3819
3820     const int c = fgetc (fd);
3821
3822     if (c == EOF) break;
3823
3824     wl_data->buf[wl_data->cnt] = (char) c;
3825
3826     wl_data->cnt++;
3827
3828     if (c == '\n') break;
3829   }
3830
3831   // ensure stream ends with a newline
3832
3833   if (wl_data->buf[wl_data->cnt - 1] != '\n')
3834   {
3835     wl_data->cnt++;
3836
3837     wl_data->buf[wl_data->cnt - 1] = '\n';
3838   }
3839
3840   return;
3841 }
3842
3843 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845   char *ptr = buf;
3846
3847   for (u32 i = 0; i < sz; i++, ptr++)
3848   {
3849     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851     if (i == 7)
3852     {
3853       *off = i;
3854       *len = i;
3855
3856       return;
3857     }
3858
3859     if (*ptr != '\n') continue;
3860
3861     *off = i + 1;
3862
3863     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3864
3865     *len = i;
3866
3867     return;
3868   }
3869
3870   *off = sz;
3871   *len = sz;
3872 }
3873
3874 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3875 {
3876   char *ptr = buf;
3877
3878   for (u32 i = 0; i < sz; i++, ptr++)
3879   {
3880     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3881
3882     if (*ptr != '\n') continue;
3883
3884     *off = i + 1;
3885
3886     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3887
3888     *len = i;
3889
3890     return;
3891   }
3892
3893   *off = sz;
3894   *len = sz;
3895 }
3896
3897 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3898 {
3899   char *ptr = buf;
3900
3901   for (u32 i = 0; i < sz; i++, ptr++)
3902   {
3903     if (*ptr != '\n') continue;
3904
3905     *off = i + 1;
3906
3907     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3908
3909     *len = i;
3910
3911     return;
3912   }
3913
3914   *off = sz;
3915   *len = sz;
3916 }
3917
3918 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3919 {
3920   while (wl_data->pos < wl_data->cnt)
3921   {
3922     uint off;
3923     uint len;
3924
3925     char *ptr = wl_data->buf + wl_data->pos;
3926
3927     get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3928
3929     wl_data->pos += off;
3930
3931     if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3932     {
3933       char rule_buf_out[BLOCK_SIZE] = { 0 };
3934
3935       int rule_len_out = -1;
3936
3937       if (len < BLOCK_SIZE)
3938       {
3939         rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3940       }
3941
3942       if (rule_len_out < 0)
3943       {
3944         continue;
3945       }
3946
3947       if (rule_len_out > PW_MAX)
3948       {
3949         continue;
3950       }
3951     }
3952     else
3953     {
3954       if (len > PW_MAX)
3955       {
3956         continue;
3957       }
3958     }
3959
3960     *out_buf = ptr;
3961     *out_len = len;
3962
3963     return;
3964   }
3965
3966   if (feof (fd))
3967   {
3968     fprintf (stderr, "BUG feof()!!\n");
3969
3970     return;
3971   }
3972
3973   load_segment (wl_data, fd);
3974
3975   get_next_word (wl_data, fd, out_buf, out_len);
3976 }
3977
3978 #ifdef _POSIX
3979 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3980 #endif
3981
3982 #ifdef _WIN
3983 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3984 #endif
3985 {
3986   hc_signal (NULL);
3987
3988   dictstat_t d;
3989
3990   d.cnt = 0;
3991
3992   #ifdef _POSIX
3993   fstat (fileno (fd), &d.stat);
3994   #endif
3995
3996   #ifdef _WIN
3997   _fstat64 (fileno (fd), &d.stat);
3998   #endif
3999
4000   d.stat.st_mode    = 0;
4001   d.stat.st_nlink   = 0;
4002   d.stat.st_uid     = 0;
4003   d.stat.st_gid     = 0;
4004   d.stat.st_rdev    = 0;
4005   d.stat.st_atime   = 0;
4006
4007   #ifdef _POSIX
4008   d.stat.st_blksize = 0;
4009   d.stat.st_blocks  = 0;
4010   #endif
4011
4012   if (d.stat.st_size == 0) return 0;
4013
4014   dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016   if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4017   {
4018     if (d_cache)
4019     {
4020       u64 cnt = d_cache->cnt;
4021
4022       u64 keyspace = cnt;
4023
4024       if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4025       {
4026         keyspace *= data.kernel_rules_cnt;
4027       }
4028       else if (data.attack_kern == ATTACK_KERN_COMBI)
4029       {
4030         keyspace *= data.combs_cnt;
4031       }
4032
4033       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);
4034       if (data.quiet == 0) log_info ("");
4035
4036       hc_signal (sigHandler_default);
4037
4038       return (keyspace);
4039     }
4040   }
4041
4042   time_t now  = 0;
4043   time_t prev = 0;
4044
4045   u64 comp = 0;
4046   u64 cnt  = 0;
4047   u64 cnt2 = 0;
4048
4049   while (!feof (fd))
4050   {
4051     load_segment (wl_data, fd);
4052
4053     comp += wl_data->cnt;
4054
4055     u32 i = 0;
4056
4057     while (i < wl_data->cnt)
4058     {
4059       u32 len;
4060       u32 off;
4061
4062       get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4063
4064       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4065       {
4066         char rule_buf_out[BLOCK_SIZE] = { 0 };
4067
4068         int rule_len_out = -1;
4069
4070         if (len < BLOCK_SIZE)
4071         {
4072           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4073         }
4074
4075         if (rule_len_out < 0)
4076         {
4077           len = PW_MAX1;
4078         }
4079         else
4080         {
4081           len = rule_len_out;
4082         }
4083       }
4084
4085       if (len < PW_MAX1)
4086       {
4087         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4088         {
4089           cnt += data.kernel_rules_cnt;
4090         }
4091         else if (data.attack_kern == ATTACK_KERN_COMBI)
4092         {
4093           cnt += data.combs_cnt;
4094         }
4095
4096         d.cnt++;
4097       }
4098
4099       i += off;
4100
4101       cnt2++;
4102     }
4103
4104     time (&now);
4105
4106     if ((now - prev) == 0) continue;
4107
4108     float percent = (float) comp / (float) d.stat.st_size;
4109
4110     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);
4111
4112     time (&prev);
4113   }
4114
4115   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);
4116   if (data.quiet == 0) log_info ("");
4117
4118   lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4119
4120   hc_signal (sigHandler_default);
4121
4122   return (cnt);
4123 }
4124
4125 static void *thread_monitor (void *p)
4126 {
4127   uint runtime_check = 0;
4128   uint remove_check  = 0;
4129   uint status_check  = 0;
4130   uint restore_check = 0;
4131
4132   uint restore_left = data.restore_timer;
4133   uint remove_left  = data.remove_timer;
4134   uint status_left  = data.status_timer;
4135
4136   #ifdef HAVE_HWMON
4137   uint hwmon_check = 0;
4138
4139   int slowdown_warnings = 0;
4140
4141   // these variables are mainly used for fan control
4142
4143   int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4144
4145   // temperature controller "loopback" values
4146
4147   int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4148   int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4149
4150   int temp_threshold = 1; // degrees celcius
4151
4152   int fan_speed_min =  15; // in percentage
4153   int fan_speed_max = 100;
4154
4155   time_t last_temp_check_time;
4156   #endif // HAVE_HWMON
4157
4158   uint sleep_time = 1;
4159
4160   if (data.runtime)
4161   {
4162     runtime_check = 1;
4163   }
4164
4165   if (data.restore_timer)
4166   {
4167     restore_check = 1;
4168   }
4169
4170   if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4171   {
4172     remove_check = 1;
4173   }
4174
4175   if (data.status == 1)
4176   {
4177     status_check = 1;
4178   }
4179
4180   #ifdef HAVE_HWMON
4181   if (data.gpu_temp_disable == 0)
4182   {
4183     time (&last_temp_check_time);
4184
4185     hwmon_check = 1;
4186   }
4187   #endif
4188
4189   if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4190   {
4191     #ifdef HAVE_HWMON
4192     if (hwmon_check == 0)
4193     #endif
4194     return (p);
4195   }
4196
4197   while (data.shutdown_inner == 0)
4198   {
4199     hc_sleep (sleep_time);
4200
4201     if (data.devices_status != STATUS_RUNNING) continue;
4202
4203     #ifdef HAVE_HWMON
4204
4205     if (hwmon_check == 1)
4206     {
4207       hc_thread_mutex_lock (mux_adl);
4208
4209       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4210       {
4211         hc_device_param_t *device_param = &data.devices_param[device_id];
4212
4213         if (device_param->skipped) continue;
4214
4215         if (device_param->device_vendor_id == VENDOR_ID_NV)
4216         {
4217           if (data.hm_nvapi)
4218           {
4219             NV_GPU_PERF_POLICIES_INFO_PARAMS_V1   perfPolicies_info   = { 0 };
4220             NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4221
4222             perfPolicies_info.version   = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4223             perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4224
4225             hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4226
4227             perfPolicies_status.info_value = perfPolicies_info.info_value;
4228
4229             hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4230
4231             if (perfPolicies_status.throttle & 2)
4232             {
4233               if (slowdown_warnings < 3)
4234               {
4235                 if (data.quiet == 0) clear_prompt ();
4236
4237                 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4238
4239                 if (slowdown_warnings == 2)
4240                 {
4241                   log_info ("");
4242                 }
4243
4244                 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4245                 if (data.quiet == 0) fflush (stdout);
4246
4247                 slowdown_warnings++;
4248               }
4249             }
4250             else
4251             {
4252               slowdown_warnings = 0;
4253             }
4254           }
4255         }
4256       }
4257
4258       hc_thread_mutex_unlock (mux_adl);
4259     }
4260
4261     if (hwmon_check == 1)
4262     {
4263       hc_thread_mutex_lock (mux_adl);
4264
4265       time_t temp_check_time;
4266
4267       time (&temp_check_time);
4268
4269       uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4270
4271       if (Ta == 0) Ta = 1;
4272
4273       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4274       {
4275         hc_device_param_t *device_param = &data.devices_param[device_id];
4276
4277         if (device_param->skipped) continue;
4278
4279         if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4280
4281         const int temperature = hm_get_temperature_with_device_id (device_id);
4282
4283         if (temperature > (int) data.gpu_temp_abort)
4284         {
4285           log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4286
4287           if (data.devices_status != STATUS_QUIT) myabort ();
4288
4289           break;
4290         }
4291
4292         const int gpu_temp_retain = data.gpu_temp_retain;
4293
4294         if (gpu_temp_retain)
4295         {
4296           if (data.hm_device[device_id].fan_set_supported == 1)
4297           {
4298             int temp_cur = temperature;
4299
4300             int temp_diff_new = gpu_temp_retain - temp_cur;
4301
4302             temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4303
4304             // calculate Ta value (time difference in seconds between the last check and this check)
4305
4306             last_temp_check_time = temp_check_time;
4307
4308             float Kp = 1.8;
4309             float Ki = 0.005;
4310             float Kd = 6;
4311
4312             // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4313
4314             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);
4315
4316             if (abs (fan_diff_required) >= temp_threshold)
4317             {
4318               const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4319
4320               int fan_speed_level = fan_speed_cur;
4321
4322               if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4323
4324               int fan_speed_new = fan_speed_level - fan_diff_required;
4325
4326               if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4327               if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4328
4329               if (fan_speed_new != fan_speed_cur)
4330               {
4331                 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4332                 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4333
4334                 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4335                 {
4336                   if (device_param->device_vendor_id == VENDOR_ID_AMD)
4337                   {
4338                     hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4339                   }
4340                   else if (device_param->device_vendor_id == VENDOR_ID_NV)
4341                   {
4342                     #ifdef WIN
4343                     hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4344                     #endif
4345
4346                     #ifdef LINUX
4347                     hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4348                     #endif
4349                   }
4350
4351                   fan_speed_chgd[device_id] = 1;
4352                 }
4353
4354                 temp_diff_old[device_id] = temp_diff_new;
4355               }
4356             }
4357           }
4358         }
4359       }
4360
4361       hc_thread_mutex_unlock (mux_adl);
4362     }
4363     #endif // HAVE_HWMON
4364
4365     if (restore_check == 1)
4366     {
4367       restore_left--;
4368
4369       if (restore_left == 0)
4370       {
4371         if (data.restore_disable == 0) cycle_restore ();
4372
4373         restore_left = data.restore_timer;
4374       }
4375     }
4376
4377     if ((runtime_check == 1) && (data.runtime_start > 0))
4378     {
4379       time_t runtime_cur;
4380
4381       time (&runtime_cur);
4382
4383       int runtime_left = data.proc_start + data.runtime - runtime_cur;
4384
4385       if (runtime_left <= 0)
4386       {
4387         if (data.benchmark == 0)
4388         {
4389           if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4390         }
4391
4392         if (data.devices_status != STATUS_QUIT) myabort ();
4393       }
4394     }
4395
4396     if (remove_check == 1)
4397     {
4398       remove_left--;
4399
4400       if (remove_left == 0)
4401       {
4402         if (data.digests_saved != data.digests_done)
4403         {
4404           data.digests_saved = data.digests_done;
4405
4406           save_hash ();
4407         }
4408
4409         remove_left = data.remove_timer;
4410       }
4411     }
4412
4413     if (status_check == 1)
4414     {
4415       status_left--;
4416
4417       if (status_left == 0)
4418       {
4419         hc_thread_mutex_lock (mux_display);
4420
4421         if (data.quiet == 0) clear_prompt ();
4422
4423         if (data.quiet == 0) log_info ("");
4424
4425         status_display ();
4426
4427         if (data.quiet == 0) log_info ("");
4428
4429         hc_thread_mutex_unlock (mux_display);
4430
4431         status_left = data.status_timer;
4432       }
4433     }
4434   }
4435
4436   #ifdef HAVE_HWMON
4437   myfree (fan_speed_chgd);
4438
4439   myfree (temp_diff_old);
4440   myfree (temp_diff_sum);
4441   #endif
4442
4443   p = NULL;
4444
4445   return (p);
4446 }
4447
4448 static void *thread_outfile_remove (void *p)
4449 {
4450   // some hash-dependent constants
4451   char *outfile_dir = data.outfile_check_directory;
4452   uint dgst_size    = data.dgst_size;
4453   uint isSalted     = data.isSalted;
4454   uint esalt_size   = data.esalt_size;
4455   uint hash_mode    = data.hash_mode;
4456
4457   uint outfile_check_timer = data.outfile_check_timer;
4458
4459   char separator = data.separator;
4460
4461   // some hash-dependent functions
4462   int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4463   int (*parse_func) (char *, uint, hash_t *)         = data.parse_func;
4464
4465   // buffers
4466   hash_t hash_buf = { 0, 0, 0, 0, 0 };
4467
4468   hash_buf.digest = mymalloc (dgst_size);
4469
4470   if (isSalted)   hash_buf.salt =  (salt_t *) mymalloc (sizeof (salt_t));
4471
4472   if (esalt_size) hash_buf.esalt = (void   *) mymalloc (esalt_size);
4473
4474   uint digest_buf[64] = { 0 };
4475
4476   outfile_data_t *out_info = NULL;
4477
4478   char **out_files = NULL;
4479
4480   time_t folder_mtime = 0;
4481
4482   int  out_cnt = 0;
4483
4484   uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4485
4486   while (data.shutdown_inner == 0)
4487   {
4488     hc_sleep (1);
4489
4490     if (data.devices_status != STATUS_RUNNING) continue;
4491
4492     check_left--;
4493
4494     if (check_left == 0)
4495     {
4496       struct stat outfile_check_stat;
4497
4498       if (stat (outfile_dir, &outfile_check_stat) == 0)
4499       {
4500         uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4501
4502         if (is_dir == 1)
4503         {
4504           if (outfile_check_stat.st_mtime > folder_mtime)
4505           {
4506             char **out_files_new = scan_directory (outfile_dir);
4507
4508             int out_cnt_new = count_dictionaries (out_files_new);
4509
4510             outfile_data_t *out_info_new = NULL;
4511
4512             if (out_cnt_new > 0)
4513             {
4514               out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4515
4516               for (int i = 0; i < out_cnt_new; i++)
4517               {
4518                 out_info_new[i].file_name = out_files_new[i];
4519
4520                 // check if there are files that we have seen/checked before (and not changed)
4521
4522                 for (int j = 0; j < out_cnt; j++)
4523                 {
4524                   if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4525                   {
4526                     struct stat outfile_stat;
4527
4528                     if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4529                     {
4530                       if (outfile_stat.st_ctime == out_info[j].ctime)
4531                       {
4532                         out_info_new[i].ctime = out_info[j].ctime;
4533                         out_info_new[i].seek  = out_info[j].seek;
4534                       }
4535                     }
4536                   }
4537                 }
4538               }
4539             }
4540
4541             local_free (out_info);
4542             local_free (out_files);
4543
4544             out_files = out_files_new;
4545             out_cnt   = out_cnt_new;
4546             out_info  = out_info_new;
4547
4548             folder_mtime = outfile_check_stat.st_mtime;
4549           }
4550
4551           for (int j = 0; j < out_cnt; j++)
4552           {
4553             FILE *fp = fopen (out_info[j].file_name, "rb");
4554
4555             if (fp != NULL)
4556             {
4557               //hc_thread_mutex_lock (mux_display);
4558
4559               #ifdef _POSIX
4560               struct stat outfile_stat;
4561
4562               fstat (fileno (fp), &outfile_stat);
4563               #endif
4564
4565               #ifdef _WIN
4566               struct stat64 outfile_stat;
4567
4568               _fstat64 (fileno (fp), &outfile_stat);
4569               #endif
4570
4571               if (outfile_stat.st_ctime > out_info[j].ctime)
4572               {
4573                 out_info[j].ctime = outfile_stat.st_ctime;
4574                 out_info[j].seek  = 0;
4575               }
4576
4577               fseek (fp, out_info[j].seek, SEEK_SET);
4578
4579               char *line_buf = (char *) mymalloc (HCBUFSIZ);
4580
4581               while (!feof (fp))
4582               {
4583                 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4584
4585                 if (ptr == NULL) break;
4586
4587                 int line_len = strlen (line_buf);
4588
4589                 if (line_len <= 0) continue;
4590
4591                 int iter = MAX_CUT_TRIES;
4592
4593                 for (uint i = line_len - 1; i && iter; i--, line_len--)
4594                 {
4595                   if (line_buf[i] != separator) continue;
4596
4597                   int parser_status = PARSER_OK;
4598
4599                   if ((hash_mode != 2500) && (hash_mode != 6800))
4600                   {
4601                     parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4602                   }
4603
4604                   uint found = 0;
4605
4606                   if (parser_status == PARSER_OK)
4607                   {
4608                     for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4609                     {
4610                       if (data.salts_shown[salt_pos] == 1) continue;
4611
4612                       salt_t *salt_buf = &data.salts_buf[salt_pos];
4613
4614                       for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4615                       {
4616                         uint idx = salt_buf->digests_offset + digest_pos;
4617
4618                         if (data.digests_shown[idx] == 1) continue;
4619
4620                         uint cracked = 0;
4621
4622                         if (hash_mode == 6800)
4623                         {
4624                           if (i == salt_buf->salt_len)
4625                           {
4626                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4627                           }
4628                         }
4629                         else if (hash_mode == 2500)
4630                         {
4631                           // BSSID : MAC1 : MAC2 (:plain)
4632                           if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4633                           {
4634                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4635
4636                             if (!cracked) continue;
4637
4638                             // now compare MAC1 and MAC2 too, since we have this additional info
4639                             char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4640                             char *mac2_pos = mac1_pos + 12 + 1;
4641
4642                             wpa_t *wpas = (wpa_t *) data.esalts_buf;
4643                             wpa_t *wpa  = &wpas[salt_pos];
4644
4645                             // compare hex string(s) vs binary MAC address(es)
4646
4647                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4648                             {
4649                               if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4650                               {
4651                                 cracked = 0;
4652
4653                                 break;
4654                               }
4655                             }
4656
4657                             // early skip ;)
4658                             if (!cracked) continue;
4659
4660                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4661                             {
4662                               if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4663                               {
4664                                 cracked = 0;
4665
4666                                 break;
4667                               }
4668                             }
4669                           }
4670                         }
4671                         else
4672                         {
4673                           char *digests_buf_ptr = (char *) data.digests_buf;
4674
4675                           memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4676
4677                           cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4678                         }
4679
4680                         if (cracked == 1)
4681                         {
4682                           found = 1;
4683
4684                           data.digests_shown[idx] = 1;
4685
4686                           data.digests_done++;
4687
4688                           salt_buf->digests_done++;
4689
4690                           if (salt_buf->digests_done == salt_buf->digests_cnt)
4691                           {
4692                             data.salts_shown[salt_pos] = 1;
4693
4694                             data.salts_done++;
4695
4696                             if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4697                           }
4698                         }
4699                       }
4700
4701                       if (data.devices_status == STATUS_CRACKED) break;
4702                     }
4703                   }
4704
4705                   if (found) break;
4706
4707                   if (data.devices_status == STATUS_CRACKED) break;
4708
4709                   iter--;
4710                 }
4711
4712                 if (data.devices_status == STATUS_CRACKED) break;
4713               }
4714
4715               myfree (line_buf);
4716
4717               out_info[j].seek = ftell (fp);
4718
4719               //hc_thread_mutex_unlock (mux_display);
4720
4721               fclose (fp);
4722             }
4723           }
4724         }
4725       }
4726
4727       check_left = outfile_check_timer;
4728     }
4729   }
4730
4731   if (esalt_size) local_free (hash_buf.esalt);
4732
4733   if (isSalted)   local_free (hash_buf.salt);
4734
4735   local_free (hash_buf.digest);
4736
4737   local_free (out_info);
4738
4739   local_free (out_files);
4740
4741   p = NULL;
4742
4743   return (p);
4744 }
4745
4746 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4747 {
4748   //if (device_param->pws_cnt < device_param->kernel_power)
4749   //{
4750     pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4751
4752     u8 *ptr = (u8 *) pw->i;
4753
4754     memcpy (ptr, pw_buf, pw_len);
4755
4756     memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4757
4758     pw->pw_len = pw_len;
4759
4760     device_param->pws_cnt++;
4761   //}
4762   //else
4763   //{
4764   //  fprintf (stderr, "BUG pw_add()!!\n");
4765   //
4766   //  return;
4767   //}
4768 }
4769
4770 static void set_kernel_power_final (const u64 kernel_power_final)
4771 {
4772   if (data.quiet == 0)
4773   {
4774     clear_prompt ();
4775
4776     //log_info ("");
4777
4778     log_info ("INFO: approaching final keyspace, workload adjusted");
4779     log_info ("");
4780
4781     fprintf (stdout, "%s", PROMPT);
4782
4783     fflush (stdout);
4784   }
4785
4786   data.kernel_power_final = kernel_power_final;
4787 }
4788
4789 static u32 get_power (hc_device_param_t *device_param)
4790 {
4791   const u64 kernel_power_final = data.kernel_power_final;
4792
4793   if (kernel_power_final)
4794   {
4795     const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4796
4797     const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4798
4799     // work should be at least the hardware power available without any accelerator
4800
4801     const u64 work = MAX (words_left_device, device_param->hardware_power);
4802
4803     return work;
4804   }
4805
4806   return device_param->kernel_power;
4807 }
4808
4809 static uint get_work (hc_device_param_t *device_param, const u64 max)
4810 {
4811   hc_thread_mutex_lock (mux_dispatcher);
4812
4813   const u64 words_cur  = data.words_cur;
4814   const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4815
4816   device_param->words_off = words_cur;
4817
4818   const u64 kernel_power_all = data.kernel_power_all;
4819
4820   const u64 words_left = words_base - words_cur;
4821
4822   if (words_left < kernel_power_all)
4823   {
4824     if (data.kernel_power_final == 0)
4825     {
4826       set_kernel_power_final (words_left);
4827     }
4828   }
4829
4830   const u32 kernel_power = get_power (device_param);
4831
4832   uint work = MIN (words_left, kernel_power);
4833
4834   work = MIN (work, max);
4835
4836   data.words_cur += work;
4837
4838   hc_thread_mutex_unlock (mux_dispatcher);
4839
4840   return work;
4841 }
4842
4843 static void *thread_autotune (void *p)
4844 {
4845   hc_device_param_t *device_param = (hc_device_param_t *) p;
4846
4847   if (device_param->skipped) return NULL;
4848
4849   autotune (device_param);
4850
4851   return NULL;
4852 }
4853
4854 static void *thread_calc_stdin (void *p)
4855 {
4856   hc_device_param_t *device_param = (hc_device_param_t *) p;
4857
4858   if (device_param->skipped) return NULL;
4859
4860   char *buf = (char *) mymalloc (HCBUFSIZ);
4861
4862   const uint attack_kern = data.attack_kern;
4863
4864   while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4865   {
4866     hc_thread_mutex_lock (mux_dispatcher);
4867
4868     if (feof (stdin) != 0)
4869     {
4870       hc_thread_mutex_unlock (mux_dispatcher);
4871
4872       break;
4873     }
4874
4875     uint words_cur = 0;
4876
4877     while (words_cur < device_param->kernel_power)
4878     {
4879       char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4880
4881       if (line_buf == NULL) break;
4882
4883       uint line_len = in_superchop (line_buf);
4884
4885       line_len = convert_from_hex (line_buf, line_len);
4886
4887       // post-process rule engine
4888
4889       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4890       {
4891         char rule_buf_out[BLOCK_SIZE] = { 0 };
4892
4893         int rule_len_out = -1;
4894
4895         if (line_len < BLOCK_SIZE)
4896         {
4897           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4898         }
4899
4900         if (rule_len_out < 0) continue;
4901
4902         line_buf = rule_buf_out;
4903         line_len = rule_len_out;
4904       }
4905
4906       if (line_len > PW_MAX)
4907       {
4908         continue;
4909       }
4910
4911       // hmm that's always the case, or?
4912
4913       if (attack_kern == ATTACK_KERN_STRAIGHT)
4914       {
4915         if ((line_len < data.pw_min) || (line_len > data.pw_max))
4916         {
4917           hc_thread_mutex_lock (mux_counter);
4918
4919           for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4920           {
4921             data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4922           }
4923
4924           hc_thread_mutex_unlock (mux_counter);
4925
4926           continue;
4927         }
4928       }
4929
4930       pw_add (device_param, (u8 *) line_buf, line_len);
4931
4932       words_cur++;
4933
4934       if (data.devices_status == STATUS_CRACKED) break;
4935       if (data.devices_status == STATUS_ABORTED) break;
4936       if (data.devices_status == STATUS_QUIT)    break;
4937       if (data.devices_status == STATUS_BYPASS)  break;
4938     }
4939
4940     hc_thread_mutex_unlock (mux_dispatcher);
4941
4942     if (data.devices_status == STATUS_CRACKED) break;
4943     if (data.devices_status == STATUS_ABORTED) break;
4944     if (data.devices_status == STATUS_QUIT)    break;
4945     if (data.devices_status == STATUS_BYPASS)  break;
4946
4947     // flush
4948
4949     const uint pws_cnt = device_param->pws_cnt;
4950
4951     if (pws_cnt)
4952     {
4953       run_copy (device_param, pws_cnt);
4954
4955       run_cracker (device_param, pws_cnt);
4956
4957       device_param->pws_cnt = 0;
4958
4959       /*
4960       still required?
4961       if (attack_kern == ATTACK_KERN_STRAIGHT)
4962       {
4963         run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4964       }
4965       else if (attack_kern == ATTACK_KERN_COMBI)
4966       {
4967         run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4968       }
4969       */
4970     }
4971   }
4972
4973   device_param->kernel_accel = 0;
4974   device_param->kernel_loops = 0;
4975
4976   myfree (buf);
4977
4978   return NULL;
4979 }
4980
4981 static void *thread_calc (void *p)
4982 {
4983   hc_device_param_t *device_param = (hc_device_param_t *) p;
4984
4985   if (device_param->skipped) return NULL;
4986
4987   const uint attack_mode = data.attack_mode;
4988   const uint attack_kern = data.attack_kern;
4989
4990   if (attack_mode == ATTACK_MODE_BF)
4991   {
4992     while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4993     {
4994       const uint work = get_work (device_param, -1);
4995
4996       if (work == 0) break;
4997
4998       const u64 words_off = device_param->words_off;
4999       const u64 words_fin = words_off + work;
5000
5001       const uint pws_cnt = work;
5002
5003       device_param->pws_cnt = pws_cnt;
5004
5005       if (pws_cnt)
5006       {
5007         run_copy (device_param, pws_cnt);
5008
5009         run_cracker (device_param, pws_cnt);
5010
5011         device_param->pws_cnt = 0;
5012
5013         /*
5014         still required?
5015         run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5016         */
5017       }
5018
5019       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5020
5021       if (data.devices_status == STATUS_CRACKED) break;
5022       if (data.devices_status == STATUS_ABORTED) break;
5023       if (data.devices_status == STATUS_QUIT)    break;
5024       if (data.devices_status == STATUS_BYPASS)  break;
5025
5026       if (data.benchmark == 1) break;
5027
5028       device_param->words_done = words_fin;
5029     }
5030   }
5031   else
5032   {
5033     const uint segment_size = data.segment_size;
5034
5035     char *dictfile = data.dictfile;
5036
5037     if (attack_mode == ATTACK_MODE_COMBI)
5038     {
5039       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5040       {
5041         dictfile = data.dictfile2;
5042       }
5043     }
5044
5045     FILE *fd = fopen (dictfile, "rb");
5046
5047     if (fd == NULL)
5048     {
5049       log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5050
5051       return NULL;
5052     }
5053
5054     if (attack_mode == ATTACK_MODE_COMBI)
5055     {
5056       const uint combs_mode = data.combs_mode;
5057
5058       if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5059       {
5060         const char *dictfilec = data.dictfile2;
5061
5062         FILE *combs_fp = fopen (dictfilec, "rb");
5063
5064         if (combs_fp == NULL)
5065         {
5066           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5067
5068           fclose (fd);
5069
5070           return NULL;
5071         }
5072
5073         device_param->combs_fp = combs_fp;
5074       }
5075       else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5076       {
5077         const char *dictfilec = data.dictfile;
5078
5079         FILE *combs_fp = fopen (dictfilec, "rb");
5080
5081         if (combs_fp == NULL)
5082         {
5083           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5084
5085           fclose (fd);
5086
5087           return NULL;
5088         }
5089
5090         device_param->combs_fp = combs_fp;
5091       }
5092     }
5093
5094     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5095
5096     wl_data->buf   = (char *) mymalloc (segment_size);
5097     wl_data->avail = segment_size;
5098     wl_data->incr  = segment_size;
5099     wl_data->cnt   = 0;
5100     wl_data->pos   = 0;
5101
5102     u64 words_cur = 0;
5103
5104     while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5105     {
5106       u64 words_off = 0;
5107       u64 words_fin = 0;
5108
5109       u64 max = -1;
5110
5111       while (max)
5112       {
5113         const uint work = get_work (device_param, max);
5114
5115         if (work == 0) break;
5116
5117         max = 0;
5118
5119         words_off = device_param->words_off;
5120         words_fin = words_off + work;
5121
5122         char *line_buf;
5123         uint  line_len;
5124
5125         for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5126
5127         for ( ; words_cur < words_fin; words_cur++)
5128         {
5129           get_next_word (wl_data, fd, &line_buf, &line_len);
5130
5131           line_len = convert_from_hex (line_buf, line_len);
5132
5133           // post-process rule engine
5134
5135           if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5136           {
5137             char rule_buf_out[BLOCK_SIZE] = { 0 };
5138
5139             int rule_len_out = -1;
5140
5141             if (line_len < BLOCK_SIZE)
5142             {
5143               rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5144             }
5145
5146             if (rule_len_out < 0) continue;
5147
5148             line_buf = rule_buf_out;
5149             line_len = rule_len_out;
5150           }
5151
5152           if (attack_kern == ATTACK_KERN_STRAIGHT)
5153           {
5154             if ((line_len < data.pw_min) || (line_len > data.pw_max))
5155             {
5156               max++;
5157
5158               hc_thread_mutex_lock (mux_counter);
5159
5160               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5161               {
5162                 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5163               }
5164
5165               hc_thread_mutex_unlock (mux_counter);
5166
5167               continue;
5168             }
5169           }
5170           else if (attack_kern == ATTACK_KERN_COMBI)
5171           {
5172             // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5173             // since we still need to combine the plains
5174
5175             if (line_len > data.pw_max)
5176             {
5177               max++;
5178
5179               hc_thread_mutex_lock (mux_counter);
5180
5181               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5182               {
5183                 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5184               }
5185
5186               hc_thread_mutex_unlock (mux_counter);
5187
5188               continue;
5189             }
5190           }
5191
5192           pw_add (device_param, (u8 *) line_buf, line_len);
5193
5194           if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5195
5196           if (data.devices_status == STATUS_CRACKED) break;
5197           if (data.devices_status == STATUS_ABORTED) break;
5198           if (data.devices_status == STATUS_QUIT)    break;
5199           if (data.devices_status == STATUS_BYPASS)  break;
5200         }
5201
5202         if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5203
5204         if (data.devices_status == STATUS_CRACKED) break;
5205         if (data.devices_status == STATUS_ABORTED) break;
5206         if (data.devices_status == STATUS_QUIT)    break;
5207         if (data.devices_status == STATUS_BYPASS)  break;
5208       }
5209
5210       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5211
5212       if (data.devices_status == STATUS_CRACKED) break;
5213       if (data.devices_status == STATUS_ABORTED) break;
5214       if (data.devices_status == STATUS_QUIT)    break;
5215       if (data.devices_status == STATUS_BYPASS)  break;
5216
5217       //
5218       // flush
5219       //
5220
5221       const uint pws_cnt = device_param->pws_cnt;
5222
5223       if (pws_cnt)
5224       {
5225         run_copy (device_param, pws_cnt);
5226
5227         run_cracker (device_param, pws_cnt);
5228
5229         device_param->pws_cnt = 0;
5230
5231         /*
5232         still required?
5233         if (attack_kern == ATTACK_KERN_STRAIGHT)
5234         {
5235           run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5236         }
5237         else if (attack_kern == ATTACK_KERN_COMBI)
5238         {
5239           run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5240         }
5241         */
5242       }
5243
5244       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5245
5246       if (data.devices_status == STATUS_CRACKED) break;
5247       if (data.devices_status == STATUS_ABORTED) break;
5248       if (data.devices_status == STATUS_QUIT)    break;
5249       if (data.devices_status == STATUS_BYPASS)  break;
5250
5251       if (words_fin == 0) break;
5252
5253       device_param->words_done = words_fin;
5254     }
5255
5256     if (attack_mode == ATTACK_MODE_COMBI)
5257     {
5258       fclose (device_param->combs_fp);
5259     }
5260
5261     free (wl_data->buf);
5262     free (wl_data);
5263
5264     fclose (fd);
5265   }
5266
5267   device_param->kernel_accel = 0;
5268   device_param->kernel_loops = 0;
5269
5270   return NULL;
5271 }
5272
5273 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5274 {
5275   if (!device_param)
5276   {
5277     log_error ("ERROR: %s : Invalid argument", __func__);
5278
5279     exit (-1);
5280   }
5281
5282   salt_t *salt_buf = &data.salts_buf[salt_pos];
5283
5284   device_param->kernel_params_buf32[27] = salt_pos;
5285   device_param->kernel_params_buf32[30] = 1;
5286   device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5287   device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5288   device_param->kernel_params_buf32[33] = 0;
5289   device_param->kernel_params_buf32[34] = 1;
5290
5291   char *dictfile_old = data.dictfile;
5292
5293   const char *weak_hash_check = "weak-hash-check";
5294
5295   data.dictfile = (char *) weak_hash_check;
5296
5297   uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5298
5299   data.kernel_rules_buf[0].cmds[0] = 0;
5300
5301   /**
5302    * run the kernel
5303    */
5304
5305   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5306   {
5307     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5308   }
5309   else
5310   {
5311     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5312
5313     uint loop_step = 16;
5314
5315     const uint iter = salt_buf->salt_iter;
5316
5317     for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5318     {
5319       uint loop_left = iter - loop_pos;
5320
5321       loop_left = MIN (loop_left, loop_step);
5322
5323       device_param->kernel_params_buf32[28] = loop_pos;
5324       device_param->kernel_params_buf32[29] = loop_left;
5325
5326       run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5327     }
5328
5329     run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5330   }
5331
5332   /**
5333    * result
5334    */
5335
5336   check_cracked (device_param, salt_pos);
5337
5338   /**
5339    * cleanup
5340    */
5341
5342   device_param->kernel_params_buf32[27] = 0;
5343   device_param->kernel_params_buf32[28] = 0;
5344   device_param->kernel_params_buf32[29] = 0;
5345   device_param->kernel_params_buf32[30] = 0;
5346   device_param->kernel_params_buf32[31] = 0;
5347   device_param->kernel_params_buf32[32] = 0;
5348   device_param->kernel_params_buf32[33] = 0;
5349   device_param->kernel_params_buf32[34] = 0;
5350
5351   data.dictfile = dictfile_old;
5352
5353   data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5354 }
5355
5356 // hlfmt hashcat
5357
5358 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5359 {
5360   if (data.username == 0)
5361   {
5362     *hashbuf_pos = line_buf;
5363     *hashbuf_len = line_len;
5364   }
5365   else
5366   {
5367     char *pos = line_buf;
5368     int   len = line_len;
5369
5370     for (int i = 0; i < line_len; i++, pos++, len--)
5371     {
5372       if (line_buf[i] == data.separator)
5373       {
5374         pos++;
5375
5376         len--;
5377
5378         break;
5379       }
5380     }
5381
5382     *hashbuf_pos = pos;
5383     *hashbuf_len = len;
5384   }
5385 }
5386
5387 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5388 {
5389   char *pos = NULL;
5390   int   len = 0;
5391
5392   int sep_cnt = 0;
5393
5394   for (int i = 0; i < line_len; i++)
5395   {
5396     if (line_buf[i] == data.separator)
5397     {
5398       sep_cnt++;
5399
5400       continue;
5401     }
5402
5403     if (sep_cnt == 0)
5404     {
5405       if (pos == NULL) pos = line_buf + i;
5406
5407       len++;
5408     }
5409   }
5410
5411   *userbuf_pos = pos;
5412   *userbuf_len = len;
5413 }
5414
5415 // hlfmt pwdump
5416
5417 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5418 {
5419   int sep_cnt = 0;
5420
5421   int sep2_len = 0;
5422   int sep3_len = 0;
5423
5424   for (int i = 0; i < line_len; i++)
5425   {
5426     if (line_buf[i] == ':')
5427     {
5428       sep_cnt++;
5429
5430       continue;
5431     }
5432
5433     if (sep_cnt == 2) sep2_len++;
5434     if (sep_cnt == 3) sep3_len++;
5435   }
5436
5437   if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5438
5439   return 0;
5440 }
5441
5442 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5443 {
5444   char *pos = NULL;
5445   int   len = 0;
5446
5447   int sep_cnt = 0;
5448
5449   for (int i = 0; i < line_len; i++)
5450   {
5451     if (line_buf[i] == ':')
5452     {
5453       sep_cnt++;
5454
5455       continue;
5456     }
5457
5458     if (data.hash_mode == 1000)
5459     {
5460       if (sep_cnt == 3)
5461       {
5462         if (pos == NULL) pos = line_buf + i;
5463
5464         len++;
5465       }
5466     }
5467     else if (data.hash_mode == 3000)
5468     {
5469       if (sep_cnt == 2)
5470       {
5471         if (pos == NULL) pos = line_buf + i;
5472
5473         len++;
5474       }
5475     }
5476   }
5477
5478   *hashbuf_pos = pos;
5479   *hashbuf_len = len;
5480 }
5481
5482 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5483 {
5484   char *pos = NULL;
5485   int   len = 0;
5486
5487   int sep_cnt = 0;
5488
5489   for (int i = 0; i < line_len; i++)
5490   {
5491     if (line_buf[i] == ':')
5492     {
5493       sep_cnt++;
5494
5495       continue;
5496     }
5497
5498     if (sep_cnt == 0)
5499     {
5500       if (pos == NULL) pos = line_buf + i;
5501
5502       len++;
5503     }
5504   }
5505
5506   *userbuf_pos = pos;
5507   *userbuf_len = len;
5508 }
5509
5510 // hlfmt passwd
5511
5512 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5513 {
5514   int sep_cnt = 0;
5515
5516   char sep5_first = 0;
5517   char sep6_first = 0;
5518
5519   for (int i = 0; i < line_len; i++)
5520   {
5521     if (line_buf[i] == ':')
5522     {
5523       sep_cnt++;
5524
5525       continue;
5526     }
5527
5528     if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5529     if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5530   }
5531
5532   if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5533
5534   return 0;
5535 }
5536
5537 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5538 {
5539   char *pos = NULL;
5540   int   len = 0;
5541
5542   int sep_cnt = 0;
5543
5544   for (int i = 0; i < line_len; i++)
5545   {
5546     if (line_buf[i] == ':')
5547     {
5548       sep_cnt++;
5549
5550       continue;
5551     }
5552
5553     if (sep_cnt == 1)
5554     {
5555       if (pos == NULL) pos = line_buf + i;
5556
5557       len++;
5558     }
5559   }
5560
5561   *hashbuf_pos = pos;
5562   *hashbuf_len = len;
5563 }
5564
5565 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5566 {
5567   char *pos = NULL;
5568   int   len = 0;
5569
5570   int sep_cnt = 0;
5571
5572   for (int i = 0; i < line_len; i++)
5573   {
5574     if (line_buf[i] == ':')
5575     {
5576       sep_cnt++;
5577
5578       continue;
5579     }
5580
5581     if (sep_cnt == 0)
5582     {
5583       if (pos == NULL) pos = line_buf + i;
5584
5585       len++;
5586     }
5587   }
5588
5589   *userbuf_pos = pos;
5590   *userbuf_len = len;
5591 }
5592
5593 // hlfmt shadow
5594
5595 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5596 {
5597   int sep_cnt = 0;
5598
5599   for (int i = 0; i < line_len; i++)
5600   {
5601     if (line_buf[i] == ':') sep_cnt++;
5602   }
5603
5604   if (sep_cnt == 8) return 1;
5605
5606   return 0;
5607 }
5608
5609 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5610 {
5611   hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5612 }
5613
5614 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5615 {
5616   hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5617 }
5618
5619 // hlfmt main
5620
5621 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5622 {
5623   switch (hashfile_format)
5624   {
5625     case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5626     case HLFMT_PWDUMP:  hlfmt_hash_pwdump  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5627     case HLFMT_PASSWD:  hlfmt_hash_passwd  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5628     case HLFMT_SHADOW:  hlfmt_hash_shadow  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5629   }
5630 }
5631
5632 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5633 {
5634   switch (hashfile_format)
5635   {
5636     case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5637     case HLFMT_PWDUMP:  hlfmt_user_pwdump  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5638     case HLFMT_PASSWD:  hlfmt_user_passwd  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5639     case HLFMT_SHADOW:  hlfmt_user_shadow  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5640   }
5641 }
5642
5643 char *strhlfmt (const uint hashfile_format)
5644 {
5645   switch (hashfile_format)
5646   {
5647     case HLFMT_HASHCAT:  return ((char *) HLFMT_TEXT_HASHCAT);  break;
5648     case HLFMT_PWDUMP:   return ((char *) HLFMT_TEXT_PWDUMP);   break;
5649     case HLFMT_PASSWD:   return ((char *) HLFMT_TEXT_PASSWD);   break;
5650     case HLFMT_SHADOW:   return ((char *) HLFMT_TEXT_SHADOW);   break;
5651     case HLFMT_DCC:      return ((char *) HLFMT_TEXT_DCC);      break;
5652     case HLFMT_DCC2:     return ((char *) HLFMT_TEXT_DCC2);     break;
5653     case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5654     case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5655     case HLFMT_NSLDAP:   return ((char *) HLFMT_TEXT_NSLDAP);   break;
5656     case HLFMT_NSLDAPS:  return ((char *) HLFMT_TEXT_NSLDAPS);  break;
5657   }
5658
5659   return ((char *) "Unknown");
5660 }
5661
5662 static uint hlfmt_detect (FILE *fp, uint max_check)
5663 {
5664   // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5665
5666   if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5667   if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5668
5669   uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5670
5671   uint num_check = 0;
5672
5673   char *line_buf = (char *) mymalloc (HCBUFSIZ);
5674
5675   while (!feof (fp))
5676   {
5677     int line_len = fgetl (fp, line_buf);
5678
5679     if (line_len == 0) continue;
5680
5681     if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5682     if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5683     if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5684
5685     if (num_check == max_check) break;
5686
5687     num_check++;
5688   }
5689
5690   myfree (line_buf);
5691
5692   uint hashlist_format = HLFMT_HASHCAT;
5693
5694   for (int i = 1; i < HLFMTS_CNT; i++)
5695   {
5696     if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5697
5698     hashlist_format = i;
5699   }
5700
5701   free (formats_cnt);
5702
5703   return hashlist_format;
5704 }
5705
5706 /**
5707  * some further helper function
5708  */
5709
5710 // wrapper around mymalloc for ADL
5711
5712 #if defined(HAVE_HWMON)
5713 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5714 {
5715   return mymalloc (iSize);
5716 }
5717 #endif
5718
5719 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)
5720 {
5721   u64 collisions = 0;
5722
5723   const uint dgst_pos0 = data.dgst_pos0;
5724   const uint dgst_pos1 = data.dgst_pos1;
5725   const uint dgst_pos2 = data.dgst_pos2;
5726   const uint dgst_pos3 = data.dgst_pos3;
5727
5728   memset (bitmap_a, 0, bitmap_size);
5729   memset (bitmap_b, 0, bitmap_size);
5730   memset (bitmap_c, 0, bitmap_size);
5731   memset (bitmap_d, 0, bitmap_size);
5732
5733   for (uint i = 0; i < digests_cnt; i++)
5734   {
5735     uint *digest_ptr = (uint *) digests_buf_ptr;
5736
5737     digests_buf_ptr += dgst_size;
5738
5739     const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5740     const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5741     const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5742     const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5743
5744     const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5745     const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5746     const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5747     const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5748
5749     if (bitmap_a[idx0] & val0) collisions++;
5750     if (bitmap_b[idx1] & val1) collisions++;
5751     if (bitmap_c[idx2] & val2) collisions++;
5752     if (bitmap_d[idx3] & val3) collisions++;
5753
5754     bitmap_a[idx0] |= val0;
5755     bitmap_b[idx1] |= val1;
5756     bitmap_c[idx2] |= val2;
5757     bitmap_d[idx3] |= val3;
5758
5759     if (collisions >= collisions_max) return 0x7fffffff;
5760   }
5761
5762   return collisions;
5763 }
5764
5765 /**
5766  * main
5767  */
5768
5769 #ifdef WIN
5770 void SetConsoleWindowSize (const int x)
5771 {
5772   HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5773
5774   if (h == INVALID_HANDLE_VALUE) return;
5775
5776   CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5777
5778   if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5779
5780   SMALL_RECT *sr = &bufferInfo.srWindow;
5781
5782   sr->Right = MAX (sr->Right, x - 1);
5783
5784   COORD co;
5785
5786   co.X = sr->Right + 1;
5787   co.Y = 9999;
5788
5789   if (!SetConsoleScreenBufferSize (h, co)) return;
5790
5791   if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5792 }
5793 #endif
5794
5795 int main (int argc, char **argv)
5796 {
5797   #ifdef WIN
5798   SetConsoleWindowSize (132);
5799   #endif
5800
5801   /**
5802    * To help users a bit
5803    */
5804
5805   char *compute = getenv ("COMPUTE");
5806
5807   if (compute)
5808   {
5809     static char display[100];
5810
5811     snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5812
5813     putenv (display);
5814   }
5815   else
5816   {
5817     if (getenv ("DISPLAY") == NULL)
5818       putenv ((char *) "DISPLAY=:0");
5819   }
5820
5821   if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5822     putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5823
5824   if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5825     putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5826
5827   if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5828     putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5829
5830   if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5831     putenv ((char *) "CUDA_CACHE_DISABLE=1");
5832
5833   if (getenv ("POCL_KERNEL_CACHE") == NULL)
5834     putenv ((char *) "POCL_KERNEL_CACHE=0");
5835
5836   umask (077);
5837
5838   /**
5839    * Real init
5840    */
5841
5842   memset (&data, 0, sizeof (hc_global_data_t));
5843
5844   time_t proc_start;
5845
5846   time (&proc_start);
5847
5848   data.proc_start = proc_start;
5849
5850   int    myargc = argc;
5851   char **myargv = argv;
5852
5853   hc_thread_mutex_init (mux_dispatcher);
5854   hc_thread_mutex_init (mux_counter);
5855   hc_thread_mutex_init (mux_display);
5856   hc_thread_mutex_init (mux_adl);
5857
5858   /**
5859    * commandline parameters
5860    */
5861
5862   uint  usage                     = USAGE;
5863   uint  version                   = VERSION;
5864   uint  quiet                     = QUIET;
5865   uint  benchmark                 = BENCHMARK;
5866   uint  stdout_flag               = STDOUT_FLAG;
5867   uint  show                      = SHOW;
5868   uint  left                      = LEFT;
5869   uint  username                  = USERNAME;
5870   uint  remove                    = REMOVE;
5871   uint  remove_timer              = REMOVE_TIMER;
5872   u64   skip                      = SKIP;
5873   u64   limit                     = LIMIT;
5874   uint  keyspace                  = KEYSPACE;
5875   uint  potfile_disable           = POTFILE_DISABLE;
5876   char *potfile_path              = NULL;
5877   uint  debug_mode                = DEBUG_MODE;
5878   char *debug_file                = NULL;
5879   char *induction_dir             = NULL;
5880   char *outfile_check_dir         = NULL;
5881   uint  force                     = FORCE;
5882   uint  runtime                   = RUNTIME;
5883   uint  hash_mode                 = HASH_MODE;
5884   uint  attack_mode               = ATTACK_MODE;
5885   uint  markov_disable            = MARKOV_DISABLE;
5886   uint  markov_classic            = MARKOV_CLASSIC;
5887   uint  markov_threshold          = MARKOV_THRESHOLD;
5888   char *markov_hcstat             = NULL;
5889   char *outfile                   = NULL;
5890   uint  outfile_format            = OUTFILE_FORMAT;
5891   uint  outfile_autohex           = OUTFILE_AUTOHEX;
5892   uint  outfile_check_timer       = OUTFILE_CHECK_TIMER;
5893   uint  restore                   = RESTORE;
5894   uint  restore_timer             = RESTORE_TIMER;
5895   uint  restore_disable           = RESTORE_DISABLE;
5896   uint  status                    = STATUS;
5897   uint  status_timer              = STATUS_TIMER;
5898   uint  machine_readable          = MACHINE_READABLE;
5899   uint  loopback                  = LOOPBACK;
5900   uint  weak_hash_threshold       = WEAK_HASH_THRESHOLD;
5901   char *session                   = NULL;
5902   uint  hex_charset               = HEX_CHARSET;
5903   uint  hex_salt                  = HEX_SALT;
5904   uint  hex_wordlist              = HEX_WORDLIST;
5905   uint  rp_gen                    = RP_GEN;
5906   uint  rp_gen_func_min           = RP_GEN_FUNC_MIN;
5907   uint  rp_gen_func_max           = RP_GEN_FUNC_MAX;
5908   uint  rp_gen_seed               = RP_GEN_SEED;
5909   char *rule_buf_l                = (char *) RULE_BUF_L;
5910   char *rule_buf_r                = (char *) RULE_BUF_R;
5911   uint  increment                 = INCREMENT;
5912   uint  increment_min             = INCREMENT_MIN;
5913   uint  increment_max             = INCREMENT_MAX;
5914   char *cpu_affinity              = NULL;
5915   OCL_PTR *ocl                    = NULL;
5916   char *opencl_devices            = NULL;
5917   char *opencl_platforms          = NULL;
5918   char *opencl_device_types       = NULL;
5919   uint  opencl_vector_width       = OPENCL_VECTOR_WIDTH;
5920   char *truecrypt_keyfiles        = NULL;
5921   char *veracrypt_keyfiles        = NULL;
5922   uint  veracrypt_pim             = 0;
5923   uint  workload_profile          = WORKLOAD_PROFILE;
5924   uint  kernel_accel              = KERNEL_ACCEL;
5925   uint  kernel_loops              = KERNEL_LOOPS;
5926   uint  nvidia_spin_damp          = NVIDIA_SPIN_DAMP;
5927   uint  gpu_temp_disable          = GPU_TEMP_DISABLE;
5928   #ifdef HAVE_HWMON
5929   uint  gpu_temp_abort            = GPU_TEMP_ABORT;
5930   uint  gpu_temp_retain           = GPU_TEMP_RETAIN;
5931   uint  powertune_enable          = POWERTUNE_ENABLE;
5932   #endif
5933   uint  logfile_disable           = LOGFILE_DISABLE;
5934   uint  segment_size              = SEGMENT_SIZE;
5935   uint  scrypt_tmto               = SCRYPT_TMTO;
5936   char  separator                 = SEPARATOR;
5937   uint  bitmap_min                = BITMAP_MIN;
5938   uint  bitmap_max                = BITMAP_MAX;
5939   char *custom_charset_1          = NULL;
5940   char *custom_charset_2          = NULL;
5941   char *custom_charset_3          = NULL;
5942   char *custom_charset_4          = NULL;
5943
5944   #define IDX_HELP                      'h'
5945   #define IDX_VERSION                   'V'
5946   #define IDX_VERSION_LOWER             'v'
5947   #define IDX_QUIET                     0xff02
5948   #define IDX_SHOW                      0xff03
5949   #define IDX_LEFT                      0xff04
5950   #define IDX_REMOVE                    0xff05
5951   #define IDX_REMOVE_TIMER              0xff37
5952   #define IDX_SKIP                      's'
5953   #define IDX_LIMIT                     'l'
5954   #define IDX_KEYSPACE                  0xff35
5955   #define IDX_POTFILE_DISABLE           0xff06
5956   #define IDX_POTFILE_PATH              0xffe0
5957   #define IDX_DEBUG_MODE                0xff43
5958   #define IDX_DEBUG_FILE                0xff44
5959   #define IDX_INDUCTION_DIR             0xff46
5960   #define IDX_OUTFILE_CHECK_DIR         0xff47
5961   #define IDX_USERNAME                  0xff07
5962   #define IDX_FORCE                     0xff08
5963   #define IDX_RUNTIME                   0xff09
5964   #define IDX_BENCHMARK                 'b'
5965   #define IDX_STDOUT_FLAG               0xff77
5966   #define IDX_HASH_MODE                 'm'
5967   #define IDX_ATTACK_MODE               'a'
5968   #define IDX_RP_FILE                   'r'
5969   #define IDX_RP_GEN                    'g'
5970   #define IDX_RP_GEN_FUNC_MIN           0xff10
5971   #define IDX_RP_GEN_FUNC_MAX           0xff11
5972   #define IDX_RP_GEN_SEED               0xff34
5973   #define IDX_RULE_BUF_L                'j'
5974   #define IDX_RULE_BUF_R                'k'
5975   #define IDX_INCREMENT                 'i'
5976   #define IDX_INCREMENT_MIN             0xff12
5977   #define IDX_INCREMENT_MAX             0xff13
5978   #define IDX_OUTFILE                   'o'
5979   #define IDX_OUTFILE_FORMAT            0xff14
5980   #define IDX_OUTFILE_AUTOHEX_DISABLE   0xff39
5981   #define IDX_OUTFILE_CHECK_TIMER       0xff45
5982   #define IDX_RESTORE                   0xff15
5983   #define IDX_RESTORE_DISABLE           0xff27
5984   #define IDX_STATUS                    0xff17
5985   #define IDX_STATUS_TIMER              0xff18
5986   #define IDX_MACHINE_READABLE          0xff50
5987   #define IDX_LOOPBACK                  0xff38
5988   #define IDX_WEAK_HASH_THRESHOLD       0xff42
5989   #define IDX_SESSION                   0xff19
5990   #define IDX_HEX_CHARSET               0xff20
5991   #define IDX_HEX_SALT                  0xff21
5992   #define IDX_HEX_WORDLIST              0xff40
5993   #define IDX_MARKOV_DISABLE            0xff22
5994   #define IDX_MARKOV_CLASSIC            0xff23
5995   #define IDX_MARKOV_THRESHOLD          't'
5996   #define IDX_MARKOV_HCSTAT             0xff24
5997   #define IDX_CPU_AFFINITY              0xff25
5998   #define IDX_OPENCL_DEVICES            'd'
5999   #define IDX_OPENCL_PLATFORMS          0xff72
6000   #define IDX_OPENCL_DEVICE_TYPES       'D'
6001   #define IDX_OPENCL_VECTOR_WIDTH       0xff74
6002   #define IDX_WORKLOAD_PROFILE          'w'
6003   #define IDX_KERNEL_ACCEL              'n'
6004   #define IDX_KERNEL_LOOPS              'u'
6005   #define IDX_NVIDIA_SPIN_DAMP          0xff79
6006   #define IDX_GPU_TEMP_DISABLE          0xff29
6007   #define IDX_GPU_TEMP_ABORT            0xff30
6008   #define IDX_GPU_TEMP_RETAIN           0xff31
6009   #define IDX_POWERTUNE_ENABLE          0xff41
6010   #define IDX_LOGFILE_DISABLE           0xff51
6011   #define IDX_TRUECRYPT_KEYFILES        0xff52
6012   #define IDX_VERACRYPT_KEYFILES        0xff53
6013   #define IDX_VERACRYPT_PIM             0xff54
6014   #define IDX_SCRYPT_TMTO               0xff61
6015   #define IDX_SEGMENT_SIZE              'c'
6016   #define IDX_SEPARATOR                 'p'
6017   #define IDX_BITMAP_MIN                0xff70
6018   #define IDX_BITMAP_MAX                0xff71
6019   #define IDX_CUSTOM_CHARSET_1          '1'
6020   #define IDX_CUSTOM_CHARSET_2          '2'
6021   #define IDX_CUSTOM_CHARSET_3          '3'
6022   #define IDX_CUSTOM_CHARSET_4          '4'
6023
6024   char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6025
6026   struct option long_options[] =
6027   {
6028     {"help",                      no_argument,       0, IDX_HELP},
6029     {"version",                   no_argument,       0, IDX_VERSION},
6030     {"quiet",                     no_argument,       0, IDX_QUIET},
6031     {"show",                      no_argument,       0, IDX_SHOW},
6032     {"left",                      no_argument,       0, IDX_LEFT},
6033     {"username",                  no_argument,       0, IDX_USERNAME},
6034     {"remove",                    no_argument,       0, IDX_REMOVE},
6035     {"remove-timer",              required_argument, 0, IDX_REMOVE_TIMER},
6036     {"skip",                      required_argument, 0, IDX_SKIP},
6037     {"limit",                     required_argument, 0, IDX_LIMIT},
6038     {"keyspace",                  no_argument,       0, IDX_KEYSPACE},
6039     {"potfile-disable",           no_argument,       0, IDX_POTFILE_DISABLE},
6040     {"potfile-path",              required_argument, 0, IDX_POTFILE_PATH},
6041     {"debug-mode",                required_argument, 0, IDX_DEBUG_MODE},
6042     {"debug-file",                required_argument, 0, IDX_DEBUG_FILE},
6043     {"induction-dir",             required_argument, 0, IDX_INDUCTION_DIR},
6044     {"outfile-check-dir",         required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6045     {"force",                     no_argument,       0, IDX_FORCE},
6046     {"benchmark",                 no_argument,       0, IDX_BENCHMARK},
6047     {"stdout",                    no_argument,       0, IDX_STDOUT_FLAG},
6048     {"restore",                   no_argument,       0, IDX_RESTORE},
6049     {"restore-disable",           no_argument,       0, IDX_RESTORE_DISABLE},
6050     {"status",                    no_argument,       0, IDX_STATUS},
6051     {"status-timer",              required_argument, 0, IDX_STATUS_TIMER},
6052     {"machine-readable",          no_argument,       0, IDX_MACHINE_READABLE},
6053     {"loopback",                  no_argument,       0, IDX_LOOPBACK},
6054     {"weak-hash-threshold",       required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6055     {"session",                   required_argument, 0, IDX_SESSION},
6056     {"runtime",                   required_argument, 0, IDX_RUNTIME},
6057     {"generate-rules",            required_argument, 0, IDX_RP_GEN},
6058     {"generate-rules-func-min",   required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6059     {"generate-rules-func-max",   required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6060     {"generate-rules-seed",       required_argument, 0, IDX_RP_GEN_SEED},
6061     {"rule-left",                 required_argument, 0, IDX_RULE_BUF_L},
6062     {"rule-right",                required_argument, 0, IDX_RULE_BUF_R},
6063     {"hash-type",                 required_argument, 0, IDX_HASH_MODE},
6064     {"attack-mode",               required_argument, 0, IDX_ATTACK_MODE},
6065     {"rules-file",                required_argument, 0, IDX_RP_FILE},
6066     {"outfile",                   required_argument, 0, IDX_OUTFILE},
6067     {"outfile-format",            required_argument, 0, IDX_OUTFILE_FORMAT},
6068     {"outfile-autohex-disable",   no_argument,       0, IDX_OUTFILE_AUTOHEX_DISABLE},
6069     {"outfile-check-timer",       required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6070     {"hex-charset",               no_argument,       0, IDX_HEX_CHARSET},
6071     {"hex-salt",                  no_argument,       0, IDX_HEX_SALT},
6072     {"hex-wordlist",              no_argument,       0, IDX_HEX_WORDLIST},
6073     {"markov-disable",            no_argument,       0, IDX_MARKOV_DISABLE},
6074     {"markov-classic",            no_argument,       0, IDX_MARKOV_CLASSIC},
6075     {"markov-threshold",          required_argument, 0, IDX_MARKOV_THRESHOLD},
6076     {"markov-hcstat",             required_argument, 0, IDX_MARKOV_HCSTAT},
6077     {"cpu-affinity",              required_argument, 0, IDX_CPU_AFFINITY},
6078     {"opencl-devices",            required_argument, 0, IDX_OPENCL_DEVICES},
6079     {"opencl-platforms",          required_argument, 0, IDX_OPENCL_PLATFORMS},
6080     {"opencl-device-types",       required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6081     {"opencl-vector-width",       required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6082     {"workload-profile",          required_argument, 0, IDX_WORKLOAD_PROFILE},
6083     {"kernel-accel",              required_argument, 0, IDX_KERNEL_ACCEL},
6084     {"kernel-loops",              required_argument, 0, IDX_KERNEL_LOOPS},
6085     {"nvidia-spin-damp",          required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6086     {"gpu-temp-disable",          no_argument,       0, IDX_GPU_TEMP_DISABLE},
6087     #ifdef HAVE_HWMON
6088     {"gpu-temp-abort",            required_argument, 0, IDX_GPU_TEMP_ABORT},
6089     {"gpu-temp-retain",           required_argument, 0, IDX_GPU_TEMP_RETAIN},
6090     {"powertune-enable",          no_argument,       0, IDX_POWERTUNE_ENABLE},
6091     #endif // HAVE_HWMON
6092     {"logfile-disable",           no_argument,       0, IDX_LOGFILE_DISABLE},
6093     {"truecrypt-keyfiles",        required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6094     {"veracrypt-keyfiles",        required_argument, 0, IDX_VERACRYPT_KEYFILES},
6095     {"veracrypt-pim",             required_argument, 0, IDX_VERACRYPT_PIM},
6096     {"segment-size",              required_argument, 0, IDX_SEGMENT_SIZE},
6097     {"scrypt-tmto",               required_argument, 0, IDX_SCRYPT_TMTO},
6098     {"seperator",                 required_argument, 0, IDX_SEPARATOR},
6099     {"separator",                 required_argument, 0, IDX_SEPARATOR},
6100     {"bitmap-min",                required_argument, 0, IDX_BITMAP_MIN},
6101     {"bitmap-max",                required_argument, 0, IDX_BITMAP_MAX},
6102     {"increment",                 no_argument,       0, IDX_INCREMENT},
6103     {"increment-min",             required_argument, 0, IDX_INCREMENT_MIN},
6104     {"increment-max",             required_argument, 0, IDX_INCREMENT_MAX},
6105     {"custom-charset1",           required_argument, 0, IDX_CUSTOM_CHARSET_1},
6106     {"custom-charset2",           required_argument, 0, IDX_CUSTOM_CHARSET_2},
6107     {"custom-charset3",           required_argument, 0, IDX_CUSTOM_CHARSET_3},
6108     {"custom-charset4",           required_argument, 0, IDX_CUSTOM_CHARSET_4},
6109     {0, 0, 0, 0}
6110   };
6111
6112   uint rp_files_cnt = 0;
6113
6114   char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6115
6116   int option_index = 0;
6117   int c = -1;
6118
6119   optind = 1;
6120   optopt = 0;
6121
6122   while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6123   {
6124     switch (c)
6125     {
6126       case IDX_HELP:          usage   = 1;      break;
6127       case IDX_VERSION:
6128       case IDX_VERSION_LOWER: version = 1;      break;
6129       case IDX_RESTORE:       restore = 1;      break;
6130       case IDX_SESSION:       session = optarg; break;
6131       case IDX_SHOW:          show    = 1;      break;
6132       case IDX_LEFT:          left    = 1;      break;
6133       case '?':               return (-1);
6134     }
6135   }
6136
6137   if (optopt != 0)
6138   {
6139     log_error ("ERROR: Invalid argument specified");
6140
6141     return (-1);
6142   }
6143
6144   /**
6145    * exit functions
6146    */
6147
6148   if (version)
6149   {
6150     log_info ("%s", VERSION_TAG);
6151
6152     return (0);
6153   }
6154
6155   if (usage)
6156   {
6157     usage_big_print (PROGNAME);
6158
6159     return (0);
6160   }
6161
6162   /**
6163    * session needs to be set, always!
6164    */
6165
6166   if (session == NULL) session = (char *) PROGNAME;
6167
6168   /**
6169    * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6170    */
6171
6172   char *exec_path = get_exec_path ();
6173
6174
6175   #if defined(LINUX) || defined(__APPLE__) || defined(__FreeBSD__)
6176
6177   char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6178   char *resolved_exec_path      = realpath (exec_path, NULL);
6179
6180   if (resolved_install_folder == NULL)
6181   {
6182     log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6183
6184     return (-1);
6185   }
6186
6187   if (resolved_exec_path == NULL)
6188   {
6189     log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6190
6191     return (-1);
6192   }
6193
6194   char *install_dir = get_install_dir (resolved_exec_path);
6195   char *profile_dir = NULL;
6196   char *session_dir = NULL;
6197   char *shared_dir  = NULL;
6198
6199   if (strcmp (install_dir, resolved_install_folder) == 0)
6200   {
6201     struct passwd *pw = getpwuid (getuid ());
6202
6203     const char *homedir = pw->pw_dir;
6204
6205     profile_dir = get_profile_dir (homedir);
6206     session_dir = get_session_dir (profile_dir);
6207     shared_dir  = strdup (SHARED_FOLDER);
6208
6209     mkdir (profile_dir, 0700);
6210     mkdir (session_dir, 0700);
6211   }
6212   else
6213   {
6214     profile_dir = install_dir;
6215     session_dir = install_dir;
6216     shared_dir  = install_dir;
6217   }
6218
6219   myfree (resolved_install_folder);
6220   myfree (resolved_exec_path);
6221
6222   #else
6223
6224   char *install_dir = get_install_dir (exec_path);
6225   char *profile_dir = install_dir;
6226   char *session_dir = install_dir;
6227   char *shared_dir  = install_dir;
6228
6229   #endif
6230
6231   data.install_dir = install_dir;
6232   data.profile_dir = profile_dir;
6233   data.session_dir = session_dir;
6234   data.shared_dir  = shared_dir;
6235
6236   myfree (exec_path);
6237
6238   /**
6239    * kernel cache, we need to make sure folder exist
6240    */
6241
6242   int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6243
6244   char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6245
6246   snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6247
6248   mkdir (kernels_folder, 0700);
6249
6250   myfree (kernels_folder);
6251
6252   /**
6253    * session
6254    */
6255
6256   size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6257
6258   data.session = session;
6259
6260   char *eff_restore_file = (char *) mymalloc (session_size);
6261   char *new_restore_file = (char *) mymalloc (session_size);
6262
6263   snprintf (eff_restore_file, session_size - 1, "%s/%s.restore",     data.session_dir, session);
6264   snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6265
6266   data.eff_restore_file = eff_restore_file;
6267   data.new_restore_file = new_restore_file;
6268
6269   if (((show == 1) || (left == 1)) && (restore == 1))
6270   {
6271     if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6272     else           log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6273
6274     return (-1);
6275   }
6276
6277   // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6278   if ((show == 1) || (left == 1))
6279   {
6280     restore_disable = 1;
6281
6282     restore = 0;
6283   }
6284
6285   data.restore_disable = restore_disable;
6286
6287   restore_data_t *rd = init_restore (argc, argv);
6288
6289   data.rd = rd;
6290
6291   /**
6292    * restore file
6293    */
6294
6295   if (restore == 1)
6296   {
6297     read_restore (eff_restore_file, rd);
6298
6299     if (rd->version_bin < RESTORE_MIN)
6300     {
6301       log_error ("ERROR: Incompatible restore-file version");
6302
6303       return (-1);
6304     }
6305
6306     myargc = rd->argc;
6307     myargv = rd->argv;
6308
6309     #ifdef _POSIX
6310     rd->pid = getpid ();
6311     #elif _WIN
6312     rd->pid = GetCurrentProcessId ();
6313     #endif
6314   }
6315
6316   uint hash_mode_chgd           = 0;
6317   uint runtime_chgd             = 0;
6318   uint kernel_loops_chgd        = 0;
6319   uint kernel_accel_chgd        = 0;
6320   uint nvidia_spin_damp_chgd    = 0;
6321   uint attack_mode_chgd         = 0;
6322   uint outfile_format_chgd      = 0;
6323   uint rp_gen_seed_chgd         = 0;
6324   uint remove_timer_chgd        = 0;
6325   uint increment_min_chgd       = 0;
6326   uint increment_max_chgd       = 0;
6327   uint workload_profile_chgd    = 0;
6328   uint opencl_vector_width_chgd = 0;
6329
6330   optind = 1;
6331   optopt = 0;
6332   option_index = 0;
6333
6334   while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6335   {
6336     switch (c)
6337     {
6338     //case IDX_HELP:                      usage                     = 1;              break;
6339     //case IDX_VERSION:                   version                   = 1;              break;
6340     //case IDX_RESTORE:                   restore                   = 1;              break;
6341       case IDX_QUIET:                     quiet                     = 1;              break;
6342     //case IDX_SHOW:                      show                      = 1;              break;
6343       case IDX_SHOW:                                                                  break;
6344     //case IDX_LEFT:                      left                      = 1;              break;
6345       case IDX_LEFT:                                                                  break;
6346       case IDX_USERNAME:                  username                  = 1;              break;
6347       case IDX_REMOVE:                    remove                    = 1;              break;
6348       case IDX_REMOVE_TIMER:              remove_timer              = atoi (optarg);
6349                                           remove_timer_chgd         = 1;              break;
6350       case IDX_POTFILE_DISABLE:           potfile_disable           = 1;              break;
6351       case IDX_POTFILE_PATH:              potfile_path              = optarg;         break;
6352       case IDX_DEBUG_MODE:                debug_mode                = atoi (optarg);  break;
6353       case IDX_DEBUG_FILE:                debug_file                = optarg;         break;
6354       case IDX_INDUCTION_DIR:             induction_dir             = optarg;         break;
6355       case IDX_OUTFILE_CHECK_DIR:         outfile_check_dir         = optarg;         break;
6356       case IDX_FORCE:                     force                     = 1;              break;
6357       case IDX_SKIP:                      skip                      = atoll (optarg); break;
6358       case IDX_LIMIT:                     limit                     = atoll (optarg); break;
6359       case IDX_KEYSPACE:                  keyspace                  = 1;              break;
6360       case IDX_BENCHMARK:                 benchmark                 = 1;              break;
6361       case IDX_STDOUT_FLAG:               stdout_flag               = 1;              break;
6362       case IDX_RESTORE:                                                               break;
6363       case IDX_RESTORE_DISABLE:           restore_disable           = 1;              break;
6364       case IDX_STATUS:                    status                    = 1;              break;
6365       case IDX_STATUS_TIMER:              status_timer              = atoi (optarg);  break;
6366       case IDX_MACHINE_READABLE:          machine_readable          = 1;              break;
6367       case IDX_LOOPBACK:                  loopback                  = 1;              break;
6368       case IDX_WEAK_HASH_THRESHOLD:       weak_hash_threshold       = atoi (optarg);  break;
6369     //case IDX_SESSION:                   session                   = optarg;         break;
6370       case IDX_SESSION:                                                               break;
6371       case IDX_HASH_MODE:                 hash_mode                 = atoi (optarg);
6372                                           hash_mode_chgd            = 1;              break;
6373       case IDX_RUNTIME:                   runtime                   = atoi (optarg);
6374                                           runtime_chgd              = 1;              break;
6375       case IDX_ATTACK_MODE:               attack_mode               = atoi (optarg);
6376                                           attack_mode_chgd          = 1;              break;
6377       case IDX_RP_FILE:                   rp_files[rp_files_cnt++]  = optarg;         break;
6378       case IDX_RP_GEN:                    rp_gen                    = atoi (optarg);  break;
6379       case IDX_RP_GEN_FUNC_MIN:           rp_gen_func_min           = atoi (optarg);  break;
6380       case IDX_RP_GEN_FUNC_MAX:           rp_gen_func_max           = atoi (optarg);  break;
6381       case IDX_RP_GEN_SEED:               rp_gen_seed               = atoi (optarg);
6382                                           rp_gen_seed_chgd          = 1;              break;
6383       case IDX_RULE_BUF_L:                rule_buf_l                = optarg;         break;
6384       case IDX_RULE_BUF_R:                rule_buf_r                = optarg;         break;
6385       case IDX_MARKOV_DISABLE:            markov_disable            = 1;              break;
6386       case IDX_MARKOV_CLASSIC:            markov_classic            = 1;              break;
6387       case IDX_MARKOV_THRESHOLD:          markov_threshold          = atoi (optarg);  break;
6388       case IDX_MARKOV_HCSTAT:             markov_hcstat             = optarg;         break;
6389       case IDX_OUTFILE:                   outfile                   = optarg;         break;
6390       case IDX_OUTFILE_FORMAT:            outfile_format            = atoi (optarg);
6391                                           outfile_format_chgd       = 1;              break;
6392       case IDX_OUTFILE_AUTOHEX_DISABLE:   outfile_autohex           = 0;              break;
6393       case IDX_OUTFILE_CHECK_TIMER:       outfile_check_timer       = atoi (optarg);  break;
6394       case IDX_HEX_CHARSET:               hex_charset               = 1;              break;
6395       case IDX_HEX_SALT:                  hex_salt                  = 1;              break;
6396       case IDX_HEX_WORDLIST:              hex_wordlist              = 1;              break;
6397       case IDX_CPU_AFFINITY:              cpu_affinity              = optarg;         break;
6398       case IDX_OPENCL_DEVICES:            opencl_devices            = optarg;         break;
6399       case IDX_OPENCL_PLATFORMS:          opencl_platforms          = optarg;         break;
6400       case IDX_OPENCL_DEVICE_TYPES:       opencl_device_types       = optarg;         break;
6401       case IDX_OPENCL_VECTOR_WIDTH:       opencl_vector_width       = atoi (optarg);
6402                                           opencl_vector_width_chgd  = 1;              break;
6403       case IDX_WORKLOAD_PROFILE:          workload_profile          = atoi (optarg);
6404                                           workload_profile_chgd     = 1;              break;
6405       case IDX_KERNEL_ACCEL:              kernel_accel              = atoi (optarg);
6406                                           kernel_accel_chgd         = 1;              break;
6407       case IDX_KERNEL_LOOPS:              kernel_loops              = atoi (optarg);
6408                                           kernel_loops_chgd         = 1;              break;
6409       case IDX_NVIDIA_SPIN_DAMP:          nvidia_spin_damp          = atoi (optarg);
6410                                           nvidia_spin_damp_chgd     = 1;              break;
6411       case IDX_GPU_TEMP_DISABLE:          gpu_temp_disable          = 1;              break;
6412       #ifdef HAVE_HWMON
6413       case IDX_GPU_TEMP_ABORT:            gpu_temp_abort            = atoi (optarg);  break;
6414       case IDX_GPU_TEMP_RETAIN:           gpu_temp_retain           = atoi (optarg);  break;
6415       case IDX_POWERTUNE_ENABLE:          powertune_enable          = 1;              break;
6416       #endif // HAVE_HWMON
6417       case IDX_LOGFILE_DISABLE:           logfile_disable           = 1;              break;
6418       case IDX_TRUECRYPT_KEYFILES:        truecrypt_keyfiles        = optarg;         break;
6419       case IDX_VERACRYPT_KEYFILES:        veracrypt_keyfiles        = optarg;         break;
6420       case IDX_VERACRYPT_PIM:             veracrypt_pim             = atoi (optarg);  break;
6421       case IDX_SEGMENT_SIZE:              segment_size              = atoi (optarg);  break;
6422       case IDX_SCRYPT_TMTO:               scrypt_tmto               = atoi (optarg);  break;
6423       case IDX_SEPARATOR:                 separator                 = optarg[0];      break;
6424       case IDX_BITMAP_MIN:                bitmap_min                = atoi (optarg);  break;
6425       case IDX_BITMAP_MAX:                bitmap_max                = atoi (optarg);  break;
6426       case IDX_INCREMENT:                 increment                 = 1;              break;
6427       case IDX_INCREMENT_MIN:             increment_min             = atoi (optarg);
6428                                           increment_min_chgd        = 1;              break;
6429       case IDX_INCREMENT_MAX:             increment_max             = atoi (optarg);
6430                                           increment_max_chgd        = 1;              break;
6431       case IDX_CUSTOM_CHARSET_1:          custom_charset_1          = optarg;         break;
6432       case IDX_CUSTOM_CHARSET_2:          custom_charset_2          = optarg;         break;
6433       case IDX_CUSTOM_CHARSET_3:          custom_charset_3          = optarg;         break;
6434       case IDX_CUSTOM_CHARSET_4:          custom_charset_4          = optarg;         break;
6435
6436       default:
6437         log_error ("ERROR: Invalid argument specified");
6438         return (-1);
6439     }
6440   }
6441
6442   if (optopt != 0)
6443   {
6444     log_error ("ERROR: Invalid argument specified");
6445
6446     return (-1);
6447   }
6448
6449   /**
6450    * Inform user things getting started,
6451    * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6452    * - we do not need to check algorithm_pos
6453    */
6454
6455   if (quiet == 0)
6456   {
6457     if (benchmark == 1)
6458     {
6459       if (machine_readable == 0)
6460       {
6461         log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6462         log_info ("");
6463       }
6464       else
6465       {
6466         log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6467       }
6468     }
6469     else if (restore == 1)
6470     {
6471       log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6472       log_info ("");
6473     }
6474     else if (stdout_flag == 1)
6475     {
6476       // do nothing
6477     }
6478     else if (keyspace == 1)
6479     {
6480       // do nothing
6481     }
6482     else
6483     {
6484       log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6485       log_info ("");
6486     }
6487   }
6488
6489   /**
6490    * sanity check
6491    */
6492
6493   if (attack_mode > 7)
6494   {
6495     log_error ("ERROR: Invalid attack-mode specified");
6496
6497     return (-1);
6498   }
6499
6500   if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6501   {
6502     log_error ("ERROR: Invalid runtime specified");
6503
6504     return (-1);
6505   }
6506
6507   if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6508   {
6509     log_error ("ERROR: Invalid hash-type specified");
6510
6511     return (-1);
6512   }
6513
6514   // renamed hash modes
6515
6516   if (hash_mode_chgd)
6517   {
6518     int n = -1;
6519
6520     switch (hash_mode)
6521     {
6522       case 123: n = 124;
6523                 break;
6524     }
6525
6526     if (n >= 0)
6527     {
6528       log_error ("Old -m specified, use -m %d instead", n);
6529
6530       return (-1);
6531     }
6532   }
6533
6534   if (username == 1)
6535   {
6536     if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6537     {
6538       log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6539
6540       return (-1);
6541     }
6542   }
6543
6544   if (outfile_format > 16)
6545   {
6546     log_error ("ERROR: Invalid outfile-format specified");
6547
6548     return (-1);
6549   }
6550
6551   if (left == 1)
6552   {
6553     if (outfile_format_chgd == 1)
6554     {
6555       if (outfile_format > 1)
6556       {
6557         log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6558
6559         return (-1);
6560       }
6561     }
6562     else
6563     {
6564       outfile_format = OUTFILE_FMT_HASH;
6565     }
6566   }
6567
6568   if (show == 1)
6569   {
6570     if (outfile_format_chgd == 1)
6571     {
6572       if ((outfile_format > 7) && (outfile_format < 16))
6573       {
6574         log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6575
6576         return (-1);
6577       }
6578     }
6579   }
6580
6581   if (increment_min < INCREMENT_MIN)
6582   {
6583     log_error ("ERROR: Invalid increment-min specified");
6584
6585     return (-1);
6586   }
6587
6588   if (increment_max > INCREMENT_MAX)
6589   {
6590     log_error ("ERROR: Invalid increment-max specified");
6591
6592     return (-1);
6593   }
6594
6595   if (increment_min > increment_max)
6596   {
6597     log_error ("ERROR: Invalid increment-min specified");
6598
6599     return (-1);
6600   }
6601
6602   if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6603   {
6604     log_error ("ERROR: Increment is not allowed in attack-mode 0");
6605
6606     return (-1);
6607   }
6608
6609   if ((increment == 0) && (increment_min_chgd == 1))
6610   {
6611     log_error ("ERROR: Increment-min is only supported combined with increment switch");
6612
6613     return (-1);
6614   }
6615
6616   if ((increment == 0) && (increment_max_chgd == 1))
6617   {
6618     log_error ("ERROR: Increment-max is only supported combined with increment switch");
6619
6620     return (-1);
6621   }
6622
6623   if (rp_files_cnt && rp_gen)
6624   {
6625     log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6626
6627     return (-1);
6628   }
6629
6630   if (rp_files_cnt || rp_gen)
6631   {
6632     if (attack_mode != ATTACK_MODE_STRAIGHT)
6633     {
6634       log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6635
6636       return (-1);
6637     }
6638   }
6639
6640   if (rp_gen_func_min > rp_gen_func_max)
6641   {
6642     log_error ("ERROR: Invalid rp-gen-func-min specified");
6643
6644     return (-1);
6645   }
6646
6647   if (kernel_accel_chgd == 1)
6648   {
6649     if (force == 0)
6650     {
6651       log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6652       log_info ("Please consider using the -w option instead");
6653       log_info ("You can use --force to override this but do not post error reports if you do so");
6654       log_info ("");
6655
6656       return (-1);
6657     }
6658
6659     if (kernel_accel < 1)
6660     {
6661       log_error ("ERROR: Invalid kernel-accel specified");
6662
6663       return (-1);
6664     }
6665
6666     if (kernel_accel > 1024)
6667     {
6668       log_error ("ERROR: Invalid kernel-accel specified");
6669
6670       return (-1);
6671     }
6672   }
6673
6674   if (kernel_loops_chgd == 1)
6675   {
6676     if (force == 0)
6677     {
6678       log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6679       log_info ("Please consider using the -w option instead");
6680       log_info ("You can use --force to override this but do not post error reports if you do so");
6681       log_info ("");
6682
6683       return (-1);
6684     }
6685
6686     if (kernel_loops < 1)
6687     {
6688       log_error ("ERROR: Invalid kernel-loops specified");
6689
6690       return (-1);
6691     }
6692
6693     if (kernel_loops > 1024)
6694     {
6695       log_error ("ERROR: Invalid kernel-loops specified");
6696
6697       return (-1);
6698     }
6699   }
6700
6701   if ((workload_profile < 1) || (workload_profile > 4))
6702   {
6703     log_error ("ERROR: workload-profile %i not available", workload_profile);
6704
6705     return (-1);
6706   }
6707
6708   if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6709   {
6710     log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6711
6712     return (-1);
6713   }
6714
6715   if (show == 1 || left == 1)
6716   {
6717     attack_mode = ATTACK_MODE_NONE;
6718
6719     if (remove == 1)
6720     {
6721       log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6722
6723       return (-1);
6724     }
6725
6726     if (potfile_disable == 1)
6727     {
6728       log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6729
6730       return (-1);
6731     }
6732   }
6733
6734   uint attack_kern = ATTACK_KERN_NONE;
6735
6736   switch (attack_mode)
6737   {
6738     case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6739     case ATTACK_MODE_COMBI:    attack_kern = ATTACK_KERN_COMBI;    break;
6740     case ATTACK_MODE_BF:       attack_kern = ATTACK_KERN_BF;       break;
6741     case ATTACK_MODE_HYBRID1:  attack_kern = ATTACK_KERN_COMBI;    break;
6742     case ATTACK_MODE_HYBRID2:  attack_kern = ATTACK_KERN_COMBI;    break;
6743   }
6744
6745   if (benchmark == 1)
6746   {
6747     if (myargv[optind] != 0)
6748     {
6749       log_error ("ERROR: Invalid argument for benchmark mode specified");
6750
6751       return (-1);
6752     }
6753
6754     if (attack_mode_chgd == 1)
6755     {
6756       if (attack_mode != ATTACK_MODE_BF)
6757       {
6758         log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6759
6760         return (-1);
6761       }
6762     }
6763   }
6764   else
6765   {
6766     if (stdout_flag == 1) // no hash here
6767     {
6768       optind--;
6769     }
6770
6771     if (keyspace == 1)
6772     {
6773       int num_additional_params = 1;
6774
6775       if (attack_kern == ATTACK_KERN_COMBI)
6776       {
6777         num_additional_params = 2;
6778       }
6779
6780       int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6781
6782       if (keyspace_wordlist_specified == 0) optind--;
6783     }
6784
6785     if (attack_kern == ATTACK_KERN_NONE)
6786     {
6787       if ((optind + 1) != myargc)
6788       {
6789         usage_mini_print (myargv[0]);
6790
6791         return (-1);
6792       }
6793     }
6794     else if (attack_kern == ATTACK_KERN_STRAIGHT)
6795     {
6796       if ((optind + 1) > myargc)
6797       {
6798         usage_mini_print (myargv[0]);
6799
6800         return (-1);
6801       }
6802     }
6803     else if (attack_kern == ATTACK_KERN_COMBI)
6804     {
6805       if ((optind + 3) != myargc)
6806       {
6807         usage_mini_print (myargv[0]);
6808
6809         return (-1);
6810       }
6811     }
6812     else if (attack_kern == ATTACK_KERN_BF)
6813     {
6814       if ((optind + 1) > myargc)
6815       {
6816         usage_mini_print (myargv[0]);
6817
6818         return (-1);
6819       }
6820     }
6821     else
6822     {
6823       usage_mini_print (myargv[0]);
6824
6825       return (-1);
6826     }
6827   }
6828
6829   if (skip != 0 && limit != 0)
6830   {
6831     limit += skip;
6832   }
6833
6834   if (keyspace == 1)
6835   {
6836     if (show == 1)
6837     {
6838       log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6839
6840       return (-1);
6841     }
6842     else if (left == 1)
6843     {
6844       log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6845
6846       return (-1);
6847     }
6848
6849     potfile_disable = 1;
6850
6851     restore_disable = 1;
6852
6853     restore = 0;
6854
6855     weak_hash_threshold = 0;
6856
6857     quiet = 1;
6858   }
6859
6860   if (stdout_flag == 1)
6861   {
6862     status_timer          = 0;
6863     restore_timer         = 0;
6864     restore_disable       = 1;
6865     restore               = 0;
6866     potfile_disable       = 1;
6867     weak_hash_threshold   = 0;
6868     gpu_temp_disable      = 1;
6869     hash_mode             = 2000;
6870     quiet                 = 1;
6871     outfile_format        = OUTFILE_FMT_PLAIN;
6872     kernel_accel          = 1024;
6873     kernel_loops          = 1024;
6874     force                 = 1;
6875     outfile_check_timer   = 0;
6876     session               = "stdout";
6877     opencl_vector_width   = 1;
6878   }
6879
6880   if (remove_timer_chgd == 1)
6881   {
6882     if (remove == 0)
6883     {
6884       log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6885
6886       return (-1);
6887     }
6888
6889     if (remove_timer < 1)
6890     {
6891       log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6892
6893       return (-1);
6894     }
6895   }
6896
6897   if (loopback == 1)
6898   {
6899     if (attack_mode == ATTACK_MODE_STRAIGHT)
6900     {
6901       if ((rp_files_cnt == 0) && (rp_gen == 0))
6902       {
6903         log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6904
6905         return (-1);
6906       }
6907     }
6908     else
6909     {
6910       log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6911
6912       return (-1);
6913     }
6914   }
6915
6916   if (debug_mode > 0)
6917   {
6918     if (attack_mode != ATTACK_MODE_STRAIGHT)
6919     {
6920       log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6921
6922       return (-1);
6923     }
6924
6925     if ((rp_files_cnt == 0) && (rp_gen == 0))
6926     {
6927       log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6928
6929       return (-1);
6930     }
6931   }
6932
6933   if (debug_mode > 4)
6934   {
6935     log_error ("ERROR: Invalid debug-mode specified");
6936
6937     return (-1);
6938   }
6939
6940   if (debug_file != NULL)
6941   {
6942     if (debug_mode < 1)
6943     {
6944       log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6945
6946       return (-1);
6947     }
6948   }
6949
6950   if (induction_dir != NULL)
6951   {
6952     if (attack_mode == ATTACK_MODE_BF)
6953     {
6954       log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6955
6956       return (-1);
6957     }
6958   }
6959
6960   if (attack_mode != ATTACK_MODE_STRAIGHT)
6961   {
6962     if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6963     {
6964       log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6965
6966       return (-1);
6967     }
6968
6969     weak_hash_threshold = 0;
6970   }
6971
6972   if (nvidia_spin_damp > 100)
6973   {
6974     log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6975
6976     return (-1);
6977   }
6978
6979
6980   /**
6981    * induction directory
6982    */
6983
6984   char *induction_directory = NULL;
6985
6986   if (attack_mode != ATTACK_MODE_BF)
6987   {
6988     if (induction_dir == NULL)
6989     {
6990       induction_directory = (char *) mymalloc (session_size);
6991
6992       snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6993
6994       // create induction folder if it does not already exist
6995
6996       if (keyspace == 0)
6997       {
6998         if (rmdir (induction_directory) == -1)
6999         {
7000           if (errno == ENOENT)
7001           {
7002             // good, we can ignore
7003           }
7004           else if (errno == ENOTEMPTY)
7005           {
7006             char *induction_directory_mv = (char *) mymalloc (session_size);
7007
7008             snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7009
7010             if (rename (induction_directory, induction_directory_mv) != 0)
7011             {
7012               log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7013
7014               return (-1);
7015             }
7016           }
7017           else
7018           {
7019             log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7020
7021             return (-1);
7022           }
7023         }
7024
7025         if (mkdir (induction_directory, 0700) == -1)
7026         {
7027           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7028
7029           return (-1);
7030         }
7031       }
7032     }
7033     else
7034     {
7035       induction_directory = induction_dir;
7036     }
7037   }
7038
7039   data.induction_directory = induction_directory;
7040
7041   /**
7042    * loopback
7043    */
7044
7045   size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7046
7047   char *loopback_file = (char *) mymalloc (loopback_size);
7048
7049   /**
7050    * tuning db
7051    */
7052
7053   char tuning_db_file[256] = { 0 };
7054
7055   snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7056
7057   tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7058
7059   /**
7060    * outfile-check directory
7061    */
7062
7063   char *outfile_check_directory = NULL;
7064
7065   if (outfile_check_dir == NULL)
7066   {
7067     outfile_check_directory = (char *) mymalloc (session_size);
7068
7069     snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7070   }
7071   else
7072   {
7073     outfile_check_directory = outfile_check_dir;
7074   }
7075
7076   data.outfile_check_directory = outfile_check_directory;
7077
7078   if (keyspace == 0)
7079   {
7080     struct stat outfile_check_stat;
7081
7082     if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7083     {
7084       uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7085
7086       if (is_dir == 0)
7087       {
7088         log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7089
7090         return (-1);
7091       }
7092     }
7093     else if (outfile_check_dir == NULL)
7094     {
7095       if (mkdir (outfile_check_directory, 0700) == -1)
7096       {
7097         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7098
7099         return (-1);
7100       }
7101     }
7102   }
7103
7104   /**
7105    * special other stuff
7106    */
7107
7108   if (hash_mode == 9710)
7109   {
7110     outfile_format      = 5;
7111     outfile_format_chgd = 1;
7112   }
7113
7114   if (hash_mode == 9810)
7115   {
7116     outfile_format      = 5;
7117     outfile_format_chgd = 1;
7118   }
7119
7120   if (hash_mode == 10410)
7121   {
7122     outfile_format      = 5;
7123     outfile_format_chgd = 1;
7124   }
7125
7126   /**
7127    * store stuff
7128    */
7129
7130   data.hash_mode               = hash_mode;
7131   data.restore                 = restore;
7132   data.restore_timer           = restore_timer;
7133   data.restore_disable         = restore_disable;
7134   data.status                  = status;
7135   data.status_timer            = status_timer;
7136   data.machine_readable        = machine_readable;
7137   data.loopback                = loopback;
7138   data.runtime                 = runtime;
7139   data.remove                  = remove;
7140   data.remove_timer            = remove_timer;
7141   data.debug_mode              = debug_mode;
7142   data.debug_file              = debug_file;
7143   data.username                = username;
7144   data.quiet                   = quiet;
7145   data.outfile                 = outfile;
7146   data.outfile_format          = outfile_format;
7147   data.outfile_autohex         = outfile_autohex;
7148   data.hex_charset             = hex_charset;
7149   data.hex_salt                = hex_salt;
7150   data.hex_wordlist            = hex_wordlist;
7151   data.separator               = separator;
7152   data.rp_files                = rp_files;
7153   data.rp_files_cnt            = rp_files_cnt;
7154   data.rp_gen                  = rp_gen;
7155   data.rp_gen_seed             = rp_gen_seed;
7156   data.force                   = force;
7157   data.benchmark               = benchmark;
7158   data.skip                    = skip;
7159   data.limit                   = limit;
7160   #ifdef HAVE_HWMON
7161   data.powertune_enable        = powertune_enable;
7162   #endif
7163   data.logfile_disable         = logfile_disable;
7164   data.truecrypt_keyfiles      = truecrypt_keyfiles;
7165   data.veracrypt_keyfiles      = veracrypt_keyfiles;
7166   data.veracrypt_pim           = veracrypt_pim;
7167   data.scrypt_tmto             = scrypt_tmto;
7168   data.workload_profile        = workload_profile;
7169
7170   /**
7171    * cpu affinity
7172    */
7173
7174   if (cpu_affinity)
7175   {
7176     set_cpu_affinity (cpu_affinity);
7177   }
7178
7179   if (rp_gen_seed_chgd == 0)
7180   {
7181     srand (proc_start);
7182   }
7183   else
7184   {
7185     srand (rp_gen_seed);
7186   }
7187
7188   /**
7189    * logfile init
7190    */
7191
7192   if (logfile_disable == 0)
7193   {
7194     size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7195
7196     char *logfile = (char *) mymalloc (logfile_size);
7197
7198     snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7199
7200     data.logfile = logfile;
7201
7202     char *topid = logfile_generate_topid ();
7203
7204     data.topid = topid;
7205   }
7206
7207   // logfile_append() checks for logfile_disable internally to make it easier from here
7208
7209   #define logfile_top_msg(msg)            logfile_append ("%s\t%s",           data.topid,             (msg));
7210   #define logfile_sub_msg(msg)            logfile_append ("%s\t%s\t%s",       data.topid, data.subid, (msg));
7211   #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu",     data.topid,             (var), (val));
7212   #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7213   #define logfile_top_var_uint(var,val)   logfile_append ("%s\t%s\t%u",       data.topid,             (var), (val));
7214   #define logfile_sub_var_uint(var,val)   logfile_append ("%s\t%s\t%s\t%u",   data.topid, data.subid, (var), (val));
7215   #define logfile_top_var_char(var,val)   logfile_append ("%s\t%s\t%c",       data.topid,             (var), (val));
7216   #define logfile_sub_var_char(var,val)   logfile_append ("%s\t%s\t%s\t%c",   data.topid, data.subid, (var), (val));
7217   #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s",       data.topid,             (var), (val));
7218   #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));
7219
7220   #define logfile_top_uint64(var)         logfile_top_var_uint64 (#var, (var));
7221   #define logfile_sub_uint64(var)         logfile_sub_var_uint64 (#var, (var));
7222   #define logfile_top_uint(var)           logfile_top_var_uint   (#var, (var));
7223   #define logfile_sub_uint(var)           logfile_sub_var_uint   (#var, (var));
7224   #define logfile_top_char(var)           logfile_top_var_char   (#var, (var));
7225   #define logfile_sub_char(var)           logfile_sub_var_char   (#var, (var));
7226   #define logfile_top_string(var)         logfile_top_var_string (#var, (var));
7227   #define logfile_sub_string(var)         logfile_sub_var_string (#var, (var));
7228
7229   logfile_top_msg ("START");
7230
7231   logfile_top_uint   (attack_mode);
7232   logfile_top_uint   (attack_kern);
7233   logfile_top_uint   (benchmark);
7234   logfile_top_uint   (stdout_flag);
7235   logfile_top_uint   (bitmap_min);
7236   logfile_top_uint   (bitmap_max);
7237   logfile_top_uint   (debug_mode);
7238   logfile_top_uint   (force);
7239   logfile_top_uint   (kernel_accel);
7240   logfile_top_uint   (kernel_loops);
7241   logfile_top_uint   (nvidia_spin_damp);
7242   logfile_top_uint   (gpu_temp_disable);
7243   #ifdef HAVE_HWMON
7244   logfile_top_uint   (gpu_temp_abort);
7245   logfile_top_uint   (gpu_temp_retain);
7246   #endif
7247   logfile_top_uint   (hash_mode);
7248   logfile_top_uint   (hex_charset);
7249   logfile_top_uint   (hex_salt);
7250   logfile_top_uint   (hex_wordlist);
7251   logfile_top_uint   (increment);
7252   logfile_top_uint   (increment_max);
7253   logfile_top_uint   (increment_min);
7254   logfile_top_uint   (keyspace);
7255   logfile_top_uint   (left);
7256   logfile_top_uint   (logfile_disable);
7257   logfile_top_uint   (loopback);
7258   logfile_top_uint   (markov_classic);
7259   logfile_top_uint   (markov_disable);
7260   logfile_top_uint   (markov_threshold);
7261   logfile_top_uint   (outfile_autohex);
7262   logfile_top_uint   (outfile_check_timer);
7263   logfile_top_uint   (outfile_format);
7264   logfile_top_uint   (potfile_disable);
7265   logfile_top_string (potfile_path);
7266   #if defined(HAVE_HWMON)
7267   logfile_top_uint   (powertune_enable);
7268   #endif
7269   logfile_top_uint   (scrypt_tmto);
7270   logfile_top_uint   (quiet);
7271   logfile_top_uint   (remove);
7272   logfile_top_uint   (remove_timer);
7273   logfile_top_uint   (restore);
7274   logfile_top_uint   (restore_disable);
7275   logfile_top_uint   (restore_timer);
7276   logfile_top_uint   (rp_gen);
7277   logfile_top_uint   (rp_gen_func_max);
7278   logfile_top_uint   (rp_gen_func_min);
7279   logfile_top_uint   (rp_gen_seed);
7280   logfile_top_uint   (runtime);
7281   logfile_top_uint   (segment_size);
7282   logfile_top_uint   (show);
7283   logfile_top_uint   (status);
7284   logfile_top_uint   (machine_readable);
7285   logfile_top_uint   (status_timer);
7286   logfile_top_uint   (usage);
7287   logfile_top_uint   (username);
7288   logfile_top_uint   (version);
7289   logfile_top_uint   (weak_hash_threshold);
7290   logfile_top_uint   (workload_profile);
7291   logfile_top_uint64 (limit);
7292   logfile_top_uint64 (skip);
7293   logfile_top_char   (separator);
7294   logfile_top_string (cpu_affinity);
7295   logfile_top_string (custom_charset_1);
7296   logfile_top_string (custom_charset_2);
7297   logfile_top_string (custom_charset_3);
7298   logfile_top_string (custom_charset_4);
7299   logfile_top_string (debug_file);
7300   logfile_top_string (opencl_devices);
7301   logfile_top_string (opencl_platforms);
7302   logfile_top_string (opencl_device_types);
7303   logfile_top_uint   (opencl_vector_width);
7304   logfile_top_string (induction_dir);
7305   logfile_top_string (markov_hcstat);
7306   logfile_top_string (outfile);
7307   logfile_top_string (outfile_check_dir);
7308   logfile_top_string (rule_buf_l);
7309   logfile_top_string (rule_buf_r);
7310   logfile_top_string (session);
7311   logfile_top_string (truecrypt_keyfiles);
7312   logfile_top_string (veracrypt_keyfiles);
7313   logfile_top_uint   (veracrypt_pim);
7314
7315   /**
7316    * Init OpenCL library loader
7317    */
7318
7319   if (keyspace == 0)
7320   {
7321     ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7322
7323     ocl_init (ocl);
7324
7325     data.ocl = ocl;
7326   }
7327
7328   /**
7329    * OpenCL platform selection
7330    */
7331
7332   u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7333
7334   /**
7335    * OpenCL device selection
7336    */
7337
7338   u32 devices_filter = setup_devices_filter (opencl_devices);
7339
7340   /**
7341    * OpenCL device type selection
7342    */
7343
7344   cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7345
7346   /**
7347    * benchmark
7348    */
7349
7350   if (benchmark == 1)
7351   {
7352     /**
7353      * disable useless stuff for benchmark
7354      */
7355
7356     status_timer          = 0;
7357     restore_timer         = 0;
7358     restore_disable       = 1;
7359     potfile_disable       = 1;
7360     weak_hash_threshold   = 0;
7361     nvidia_spin_damp      = 0;
7362     gpu_temp_disable      = 1;
7363     outfile_check_timer   = 0;
7364
7365     #ifdef HAVE_HWMON
7366     if (powertune_enable == 1)
7367     {
7368       gpu_temp_disable = 0;
7369     }
7370     #endif
7371
7372     data.status_timer         = status_timer;
7373     data.restore_timer        = restore_timer;
7374     data.restore_disable      = restore_disable;
7375     data.outfile_check_timer  = outfile_check_timer;
7376
7377     /**
7378      * force attack mode to be bruteforce
7379      */
7380
7381     attack_mode = ATTACK_MODE_BF;
7382     attack_kern = ATTACK_KERN_BF;
7383
7384     if (workload_profile_chgd == 0)
7385     {
7386       workload_profile = 3;
7387
7388       data.workload_profile = workload_profile;
7389     }
7390   }
7391
7392   /**
7393    * status, monitor and outfile remove threads
7394    */
7395
7396   uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7397
7398   data.wordlist_mode = wordlist_mode;
7399
7400   if (wordlist_mode == WL_MODE_STDIN)
7401   {
7402     status = 1;
7403
7404     data.status = status;
7405   }
7406
7407   uint outer_threads_cnt = 0;
7408
7409   hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7410
7411   data.shutdown_outer = 0;
7412
7413   if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7414   {
7415     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7416     {
7417       hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7418
7419       outer_threads_cnt++;
7420     }
7421   }
7422
7423   /**
7424    * config
7425    */
7426
7427   uint hash_type   = 0;
7428   uint salt_type   = 0;
7429   uint attack_exec = 0;
7430   uint opts_type   = 0;
7431   uint kern_type   = 0;
7432   uint dgst_size   = 0;
7433   uint esalt_size  = 0;
7434   uint opti_type   = 0;
7435   uint dgst_pos0   = -1;
7436   uint dgst_pos1   = -1;
7437   uint dgst_pos2   = -1;
7438   uint dgst_pos3   = -1;
7439
7440   int (*parse_func) (char *, uint, hash_t *);
7441   int (*sort_by_digest) (const void *, const void *);
7442
7443   uint algorithm_pos = 0;
7444   uint algorithm_max = 1;
7445
7446   uint *algorithms = default_benchmark_algorithms;
7447
7448   if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7449
7450   for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7451   {
7452     /*
7453      * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7454      * the following algos are skipped entirely
7455      */
7456
7457     if (algorithm_pos > 0)
7458     {
7459       local_free (rd);
7460
7461       rd = init_restore (argc, argv);
7462
7463       data.rd = rd;
7464     }
7465
7466     /**
7467      * update hash_mode in case of multihash benchmark
7468      */
7469
7470     if (benchmark == 1)
7471     {
7472       if (hash_mode_chgd == 0)
7473       {
7474         hash_mode = algorithms[algorithm_pos];
7475
7476         data.hash_mode = hash_mode;
7477       }
7478
7479       quiet = 1;
7480
7481       data.quiet = quiet;
7482     }
7483
7484     switch (hash_mode)
7485     {
7486       case     0:  hash_type   = HASH_TYPE_MD5;
7487                    salt_type   = SALT_TYPE_NONE;
7488                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7490                                | OPTS_TYPE_PT_ADD80
7491                                | OPTS_TYPE_PT_ADDBITS14;
7492                    kern_type   = KERN_TYPE_MD5;
7493                    dgst_size   = DGST_SIZE_4_4;
7494                    parse_func  = md5_parse_hash;
7495                    sort_by_digest = sort_by_digest_4_4;
7496                    opti_type   = OPTI_TYPE_ZERO_BYTE
7497                                | OPTI_TYPE_PRECOMPUTE_INIT
7498                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7499                                | OPTI_TYPE_MEET_IN_MIDDLE
7500                                | OPTI_TYPE_EARLY_SKIP
7501                                | OPTI_TYPE_NOT_ITERATED
7502                                | OPTI_TYPE_NOT_SALTED
7503                                | OPTI_TYPE_RAW_HASH;
7504                    dgst_pos0   = 0;
7505                    dgst_pos1   = 3;
7506                    dgst_pos2   = 2;
7507                    dgst_pos3   = 1;
7508                    break;
7509
7510       case    10:  hash_type   = HASH_TYPE_MD5;
7511                    salt_type   = SALT_TYPE_INTERN;
7512                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7514                                | OPTS_TYPE_ST_ADD80
7515                                | OPTS_TYPE_ST_ADDBITS14;
7516                    kern_type   = KERN_TYPE_MD5_PWSLT;
7517                    dgst_size   = DGST_SIZE_4_4;
7518                    parse_func  = md5s_parse_hash;
7519                    sort_by_digest = sort_by_digest_4_4;
7520                    opti_type   = OPTI_TYPE_ZERO_BYTE
7521                                | OPTI_TYPE_PRECOMPUTE_INIT
7522                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7523                                | OPTI_TYPE_MEET_IN_MIDDLE
7524                                | OPTI_TYPE_EARLY_SKIP
7525                                | OPTI_TYPE_NOT_ITERATED
7526                                | OPTI_TYPE_APPENDED_SALT
7527                                | OPTI_TYPE_RAW_HASH;
7528                    dgst_pos0   = 0;
7529                    dgst_pos1   = 3;
7530                    dgst_pos2   = 2;
7531                    dgst_pos3   = 1;
7532                    break;
7533
7534       case    11:  hash_type   = HASH_TYPE_MD5;
7535                    salt_type   = SALT_TYPE_INTERN;
7536                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7538                                | OPTS_TYPE_ST_ADD80
7539                                | OPTS_TYPE_ST_ADDBITS14;
7540                    kern_type   = KERN_TYPE_MD5_PWSLT;
7541                    dgst_size   = DGST_SIZE_4_4;
7542                    parse_func  = joomla_parse_hash;
7543                    sort_by_digest = sort_by_digest_4_4;
7544                    opti_type   = OPTI_TYPE_ZERO_BYTE
7545                                | OPTI_TYPE_PRECOMPUTE_INIT
7546                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7547                                | OPTI_TYPE_MEET_IN_MIDDLE
7548                                | OPTI_TYPE_EARLY_SKIP
7549                                | OPTI_TYPE_NOT_ITERATED
7550                                | OPTI_TYPE_APPENDED_SALT
7551                                | OPTI_TYPE_RAW_HASH;
7552                    dgst_pos0   = 0;
7553                    dgst_pos1   = 3;
7554                    dgst_pos2   = 2;
7555                    dgst_pos3   = 1;
7556                    break;
7557
7558       case    12:  hash_type   = HASH_TYPE_MD5;
7559                    salt_type   = SALT_TYPE_INTERN;
7560                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7562                                | OPTS_TYPE_ST_ADD80
7563                                | OPTS_TYPE_ST_ADDBITS14;
7564                    kern_type   = KERN_TYPE_MD5_PWSLT;
7565                    dgst_size   = DGST_SIZE_4_4;
7566                    parse_func  = postgresql_parse_hash;
7567                    sort_by_digest = sort_by_digest_4_4;
7568                    opti_type   = OPTI_TYPE_ZERO_BYTE
7569                                | OPTI_TYPE_PRECOMPUTE_INIT
7570                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7571                                | OPTI_TYPE_MEET_IN_MIDDLE
7572                                | OPTI_TYPE_EARLY_SKIP
7573                                | OPTI_TYPE_NOT_ITERATED
7574                                | OPTI_TYPE_APPENDED_SALT
7575                                | OPTI_TYPE_RAW_HASH;
7576                    dgst_pos0   = 0;
7577                    dgst_pos1   = 3;
7578                    dgst_pos2   = 2;
7579                    dgst_pos3   = 1;
7580                    break;
7581
7582       case    20:  hash_type   = HASH_TYPE_MD5;
7583                    salt_type   = SALT_TYPE_INTERN;
7584                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7586                                | OPTS_TYPE_PT_ADD80
7587                                | OPTS_TYPE_PT_ADDBITS14;
7588                    kern_type   = KERN_TYPE_MD5_SLTPW;
7589                    dgst_size   = DGST_SIZE_4_4;
7590                    parse_func  = md5s_parse_hash;
7591                    sort_by_digest = sort_by_digest_4_4;
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   = 0;
7600                    dgst_pos1   = 3;
7601                    dgst_pos2   = 2;
7602                    dgst_pos3   = 1;
7603                    break;
7604
7605       case    21:  hash_type   = HASH_TYPE_MD5;
7606                    salt_type   = SALT_TYPE_INTERN;
7607                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7609                                | OPTS_TYPE_PT_ADD80
7610                                | OPTS_TYPE_PT_ADDBITS14;
7611                    kern_type   = KERN_TYPE_MD5_SLTPW;
7612                    dgst_size   = DGST_SIZE_4_4;
7613                    parse_func  = osc_parse_hash;
7614                    sort_by_digest = sort_by_digest_4_4;
7615                    opti_type   = OPTI_TYPE_ZERO_BYTE
7616                                | OPTI_TYPE_PRECOMPUTE_INIT
7617                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7618                                | OPTI_TYPE_EARLY_SKIP
7619                                | OPTI_TYPE_NOT_ITERATED
7620                                | OPTI_TYPE_PREPENDED_SALT
7621                                | OPTI_TYPE_RAW_HASH;
7622                    dgst_pos0   = 0;
7623                    dgst_pos1   = 3;
7624                    dgst_pos2   = 2;
7625                    dgst_pos3   = 1;
7626                    break;
7627
7628       case    22:  hash_type   = HASH_TYPE_MD5;
7629                    salt_type   = SALT_TYPE_EMBEDDED;
7630                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7632                                | OPTS_TYPE_PT_ADD80
7633                                | OPTS_TYPE_PT_ADDBITS14;
7634                    kern_type   = KERN_TYPE_MD5_SLTPW;
7635                    dgst_size   = DGST_SIZE_4_4;
7636                    parse_func  = netscreen_parse_hash;
7637                    sort_by_digest = sort_by_digest_4_4;
7638                    opti_type   = OPTI_TYPE_ZERO_BYTE
7639                                | OPTI_TYPE_PRECOMPUTE_INIT
7640                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7641                                | OPTI_TYPE_EARLY_SKIP
7642                                | OPTI_TYPE_NOT_ITERATED
7643                                | OPTI_TYPE_PREPENDED_SALT
7644                                | OPTI_TYPE_RAW_HASH;
7645                    dgst_pos0   = 0;
7646                    dgst_pos1   = 3;
7647                    dgst_pos2   = 2;
7648                    dgst_pos3   = 1;
7649                    break;
7650
7651       case    23:  hash_type   = HASH_TYPE_MD5;
7652                    salt_type   = SALT_TYPE_EMBEDDED;
7653                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7655                                | OPTS_TYPE_PT_ADD80
7656                                | OPTS_TYPE_PT_ADDBITS14;
7657                    kern_type   = KERN_TYPE_MD5_SLTPW;
7658                    dgst_size   = DGST_SIZE_4_4;
7659                    parse_func  = skype_parse_hash;
7660                    sort_by_digest = sort_by_digest_4_4;
7661                    opti_type   = OPTI_TYPE_ZERO_BYTE
7662                                | OPTI_TYPE_PRECOMPUTE_INIT
7663                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7664                                | OPTI_TYPE_EARLY_SKIP
7665                                | OPTI_TYPE_NOT_ITERATED
7666                                | OPTI_TYPE_PREPENDED_SALT
7667                                | OPTI_TYPE_RAW_HASH;
7668                    dgst_pos0   = 0;
7669                    dgst_pos1   = 3;
7670                    dgst_pos2   = 2;
7671                    dgst_pos3   = 1;
7672                    break;
7673
7674       case    30:  hash_type   = HASH_TYPE_MD5;
7675                    salt_type   = SALT_TYPE_INTERN;
7676                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7678                                | OPTS_TYPE_PT_UNICODE
7679                                | OPTS_TYPE_ST_ADD80
7680                                | OPTS_TYPE_ST_ADDBITS14;
7681                    kern_type   = KERN_TYPE_MD5_PWUSLT;
7682                    dgst_size   = DGST_SIZE_4_4;
7683                    parse_func  = md5s_parse_hash;
7684                    sort_by_digest = sort_by_digest_4_4;
7685                    opti_type   = OPTI_TYPE_ZERO_BYTE
7686                                | OPTI_TYPE_PRECOMPUTE_INIT
7687                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7688                                | OPTI_TYPE_MEET_IN_MIDDLE
7689                                | OPTI_TYPE_EARLY_SKIP
7690                                | OPTI_TYPE_NOT_ITERATED
7691                                | OPTI_TYPE_APPENDED_SALT
7692                                | OPTI_TYPE_RAW_HASH;
7693                    dgst_pos0   = 0;
7694                    dgst_pos1   = 3;
7695                    dgst_pos2   = 2;
7696                    dgst_pos3   = 1;
7697                    break;
7698
7699       case    40:  hash_type   = HASH_TYPE_MD5;
7700                    salt_type   = SALT_TYPE_INTERN;
7701                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7703                                | OPTS_TYPE_PT_ADD80
7704                                | OPTS_TYPE_PT_ADDBITS14
7705                                | OPTS_TYPE_PT_UNICODE;
7706                    kern_type   = KERN_TYPE_MD5_SLTPWU;
7707                    dgst_size   = DGST_SIZE_4_4;
7708                    parse_func  = md5s_parse_hash;
7709                    sort_by_digest = sort_by_digest_4_4;
7710                    opti_type   = OPTI_TYPE_ZERO_BYTE
7711                                | OPTI_TYPE_PRECOMPUTE_INIT
7712                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7713                                | OPTI_TYPE_EARLY_SKIP
7714                                | OPTI_TYPE_NOT_ITERATED
7715                                | OPTI_TYPE_PREPENDED_SALT
7716                                | OPTI_TYPE_RAW_HASH;
7717                    dgst_pos0   = 0;
7718                    dgst_pos1   = 3;
7719                    dgst_pos2   = 2;
7720                    dgst_pos3   = 1;
7721                    break;
7722
7723       case    50:  hash_type   = HASH_TYPE_MD5;
7724                    salt_type   = SALT_TYPE_INTERN;
7725                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7727                                | OPTS_TYPE_ST_ADD80
7728                                | OPTS_TYPE_ST_ADDBITS14;
7729                    kern_type   = KERN_TYPE_HMACMD5_PW;
7730                    dgst_size   = DGST_SIZE_4_4;
7731                    parse_func  = hmacmd5_parse_hash;
7732                    sort_by_digest = sort_by_digest_4_4;
7733                    opti_type   = OPTI_TYPE_ZERO_BYTE
7734                                | OPTI_TYPE_NOT_ITERATED;
7735                    dgst_pos0   = 0;
7736                    dgst_pos1   = 3;
7737                    dgst_pos2   = 2;
7738                    dgst_pos3   = 1;
7739                    break;
7740
7741       case    60:  hash_type   = HASH_TYPE_MD5;
7742                    salt_type   = SALT_TYPE_INTERN;
7743                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7745                                | OPTS_TYPE_PT_ADD80
7746                                | OPTS_TYPE_PT_ADDBITS14;
7747                    kern_type   = KERN_TYPE_HMACMD5_SLT;
7748                    dgst_size   = DGST_SIZE_4_4;
7749                    parse_func  = hmacmd5_parse_hash;
7750                    sort_by_digest = sort_by_digest_4_4;
7751                    opti_type   = OPTI_TYPE_ZERO_BYTE
7752                                | OPTI_TYPE_NOT_ITERATED;
7753                    dgst_pos0   = 0;
7754                    dgst_pos1   = 3;
7755                    dgst_pos2   = 2;
7756                    dgst_pos3   = 1;
7757                    break;
7758
7759       case   100:  hash_type   = HASH_TYPE_SHA1;
7760                    salt_type   = SALT_TYPE_NONE;
7761                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7763                                | OPTS_TYPE_PT_ADD80
7764                                | OPTS_TYPE_PT_ADDBITS15;
7765                    kern_type   = KERN_TYPE_SHA1;
7766                    dgst_size   = DGST_SIZE_4_5;
7767                    parse_func  = sha1_parse_hash;
7768                    sort_by_digest = sort_by_digest_4_5;
7769                    opti_type   = OPTI_TYPE_ZERO_BYTE
7770                                | OPTI_TYPE_PRECOMPUTE_INIT
7771                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7772                                | OPTI_TYPE_EARLY_SKIP
7773                                | OPTI_TYPE_NOT_ITERATED
7774                                | OPTI_TYPE_NOT_SALTED
7775                                | OPTI_TYPE_RAW_HASH;
7776                    dgst_pos0   = 3;
7777                    dgst_pos1   = 4;
7778                    dgst_pos2   = 2;
7779                    dgst_pos3   = 1;
7780                    break;
7781
7782       case   101:  hash_type   = HASH_TYPE_SHA1;
7783                    salt_type   = SALT_TYPE_NONE;
7784                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7786                                | OPTS_TYPE_PT_ADD80
7787                                | OPTS_TYPE_PT_ADDBITS15;
7788                    kern_type   = KERN_TYPE_SHA1;
7789                    dgst_size   = DGST_SIZE_4_5;
7790                    parse_func  = sha1b64_parse_hash;
7791                    sort_by_digest = sort_by_digest_4_5;
7792                    opti_type   = OPTI_TYPE_ZERO_BYTE
7793                                | OPTI_TYPE_PRECOMPUTE_INIT
7794                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7795                                | OPTI_TYPE_EARLY_SKIP
7796                                | OPTI_TYPE_NOT_ITERATED
7797                                | OPTI_TYPE_NOT_SALTED
7798                                | OPTI_TYPE_RAW_HASH;
7799                    dgst_pos0   = 3;
7800                    dgst_pos1   = 4;
7801                    dgst_pos2   = 2;
7802                    dgst_pos3   = 1;
7803                    break;
7804
7805       case   110:  hash_type   = HASH_TYPE_SHA1;
7806                    salt_type   = SALT_TYPE_INTERN;
7807                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7809                                | OPTS_TYPE_ST_ADD80
7810                                | OPTS_TYPE_ST_ADDBITS15;
7811                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7812                    dgst_size   = DGST_SIZE_4_5;
7813                    parse_func  = sha1s_parse_hash;
7814                    sort_by_digest = sort_by_digest_4_5;
7815                    opti_type   = OPTI_TYPE_ZERO_BYTE
7816                                | OPTI_TYPE_PRECOMPUTE_INIT
7817                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7818                                | OPTI_TYPE_EARLY_SKIP
7819                                | OPTI_TYPE_NOT_ITERATED
7820                                | OPTI_TYPE_APPENDED_SALT
7821                                | OPTI_TYPE_RAW_HASH;
7822                    dgst_pos0   = 3;
7823                    dgst_pos1   = 4;
7824                    dgst_pos2   = 2;
7825                    dgst_pos3   = 1;
7826                    break;
7827
7828       case   111:  hash_type   = HASH_TYPE_SHA1;
7829                    salt_type   = SALT_TYPE_EMBEDDED;
7830                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7832                                | OPTS_TYPE_ST_ADD80
7833                                | OPTS_TYPE_ST_ADDBITS15;
7834                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7835                    dgst_size   = DGST_SIZE_4_5;
7836                    parse_func  = sha1b64s_parse_hash;
7837                    sort_by_digest = sort_by_digest_4_5;
7838                    opti_type   = OPTI_TYPE_ZERO_BYTE
7839                                | OPTI_TYPE_PRECOMPUTE_INIT
7840                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7841                                | OPTI_TYPE_EARLY_SKIP
7842                                | OPTI_TYPE_NOT_ITERATED
7843                                | OPTI_TYPE_APPENDED_SALT
7844                                | OPTI_TYPE_RAW_HASH;
7845                    dgst_pos0   = 3;
7846                    dgst_pos1   = 4;
7847                    dgst_pos2   = 2;
7848                    dgst_pos3   = 1;
7849                    break;
7850
7851       case   112:  hash_type   = HASH_TYPE_SHA1;
7852                    salt_type   = SALT_TYPE_INTERN;
7853                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7855                                | OPTS_TYPE_ST_ADD80
7856                                | OPTS_TYPE_ST_ADDBITS15
7857                                | OPTS_TYPE_ST_HEX;
7858                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7859                    dgst_size   = DGST_SIZE_4_5;
7860                    parse_func  = oracles_parse_hash;
7861                    sort_by_digest = sort_by_digest_4_5;
7862                    opti_type   = OPTI_TYPE_ZERO_BYTE
7863                                | OPTI_TYPE_PRECOMPUTE_INIT
7864                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7865                                | OPTI_TYPE_EARLY_SKIP
7866                                | OPTI_TYPE_NOT_ITERATED
7867                                | OPTI_TYPE_APPENDED_SALT
7868                                | OPTI_TYPE_RAW_HASH;
7869                    dgst_pos0   = 3;
7870                    dgst_pos1   = 4;
7871                    dgst_pos2   = 2;
7872                    dgst_pos3   = 1;
7873                    break;
7874
7875       case   120:  hash_type   = HASH_TYPE_SHA1;
7876                    salt_type   = SALT_TYPE_INTERN;
7877                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7879                                | OPTS_TYPE_PT_ADD80
7880                                | OPTS_TYPE_PT_ADDBITS15;
7881                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7882                    dgst_size   = DGST_SIZE_4_5;
7883                    parse_func  = sha1s_parse_hash;
7884                    sort_by_digest = sort_by_digest_4_5;
7885                    opti_type   = OPTI_TYPE_ZERO_BYTE
7886                                | OPTI_TYPE_PRECOMPUTE_INIT
7887                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7888                                | OPTI_TYPE_EARLY_SKIP
7889                                | OPTI_TYPE_NOT_ITERATED
7890                                | OPTI_TYPE_PREPENDED_SALT
7891                                | OPTI_TYPE_RAW_HASH;
7892                    dgst_pos0   = 3;
7893                    dgst_pos1   = 4;
7894                    dgst_pos2   = 2;
7895                    dgst_pos3   = 1;
7896                    break;
7897
7898       case   121:  hash_type   = HASH_TYPE_SHA1;
7899                    salt_type   = SALT_TYPE_INTERN;
7900                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7902                                | OPTS_TYPE_PT_ADD80
7903                                | OPTS_TYPE_PT_ADDBITS15
7904                                | OPTS_TYPE_ST_LOWER;
7905                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7906                    dgst_size   = DGST_SIZE_4_5;
7907                    parse_func  = smf_parse_hash;
7908                    sort_by_digest = sort_by_digest_4_5;
7909                    opti_type   = OPTI_TYPE_ZERO_BYTE
7910                                | OPTI_TYPE_PRECOMPUTE_INIT
7911                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7912                                | OPTI_TYPE_EARLY_SKIP
7913                                | OPTI_TYPE_NOT_ITERATED
7914                                | OPTI_TYPE_PREPENDED_SALT
7915                                | OPTI_TYPE_RAW_HASH;
7916                    dgst_pos0   = 3;
7917                    dgst_pos1   = 4;
7918                    dgst_pos2   = 2;
7919                    dgst_pos3   = 1;
7920                    break;
7921
7922       case   122:  hash_type   = HASH_TYPE_SHA1;
7923                    salt_type   = SALT_TYPE_EMBEDDED;
7924                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7926                                | OPTS_TYPE_PT_ADD80
7927                                | OPTS_TYPE_PT_ADDBITS15
7928                                | OPTS_TYPE_ST_HEX;
7929                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7930                    dgst_size   = DGST_SIZE_4_5;
7931                    parse_func  = osx1_parse_hash;
7932                    sort_by_digest = sort_by_digest_4_5;
7933                    opti_type   = OPTI_TYPE_ZERO_BYTE
7934                                | OPTI_TYPE_PRECOMPUTE_INIT
7935                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7936                                | OPTI_TYPE_EARLY_SKIP
7937                                | OPTI_TYPE_NOT_ITERATED
7938                                | OPTI_TYPE_PREPENDED_SALT
7939                                | OPTI_TYPE_RAW_HASH;
7940                    dgst_pos0   = 3;
7941                    dgst_pos1   = 4;
7942                    dgst_pos2   = 2;
7943                    dgst_pos3   = 1;
7944                    break;
7945
7946       case   124:  hash_type   = HASH_TYPE_SHA1;
7947                    salt_type   = SALT_TYPE_EMBEDDED;
7948                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7950                                | OPTS_TYPE_PT_ADD80
7951                                | OPTS_TYPE_PT_ADDBITS15;
7952                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7953                    dgst_size   = DGST_SIZE_4_5;
7954                    parse_func  = djangosha1_parse_hash;
7955                    sort_by_digest = sort_by_digest_4_5;
7956                    opti_type   = OPTI_TYPE_ZERO_BYTE
7957                                | OPTI_TYPE_PRECOMPUTE_INIT
7958                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7959                                | OPTI_TYPE_EARLY_SKIP
7960                                | OPTI_TYPE_NOT_ITERATED
7961                                | OPTI_TYPE_PREPENDED_SALT
7962                                | OPTI_TYPE_RAW_HASH;
7963                    dgst_pos0   = 3;
7964                    dgst_pos1   = 4;
7965                    dgst_pos2   = 2;
7966                    dgst_pos3   = 1;
7967                    break;
7968
7969       case   125:  hash_type   = HASH_TYPE_SHA1;
7970                    salt_type   = SALT_TYPE_EMBEDDED;
7971                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7973                                | OPTS_TYPE_PT_ADD80
7974                                | OPTS_TYPE_PT_ADDBITS15
7975                                | OPTS_TYPE_ST_HEX;
7976                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7977                    dgst_size   = DGST_SIZE_4_5;
7978                    parse_func  = arubaos_parse_hash;
7979                    sort_by_digest = sort_by_digest_4_5;
7980                    opti_type   = OPTI_TYPE_ZERO_BYTE
7981                                | OPTI_TYPE_PRECOMPUTE_INIT
7982                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7983                                | OPTI_TYPE_EARLY_SKIP
7984                                | OPTI_TYPE_NOT_ITERATED
7985                                | OPTI_TYPE_PREPENDED_SALT
7986                                | OPTI_TYPE_RAW_HASH;
7987                    dgst_pos0   = 3;
7988                    dgst_pos1   = 4;
7989                    dgst_pos2   = 2;
7990                    dgst_pos3   = 1;
7991                    break;
7992
7993       case   130:  hash_type   = HASH_TYPE_SHA1;
7994                    salt_type   = SALT_TYPE_INTERN;
7995                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7996                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7997                                | OPTS_TYPE_PT_UNICODE
7998                                | OPTS_TYPE_ST_ADD80
7999                                | OPTS_TYPE_ST_ADDBITS15;
8000                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8001                    dgst_size   = DGST_SIZE_4_5;
8002                    parse_func  = sha1s_parse_hash;
8003                    sort_by_digest = sort_by_digest_4_5;
8004                    opti_type   = OPTI_TYPE_ZERO_BYTE
8005                                | OPTI_TYPE_PRECOMPUTE_INIT
8006                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8007                                | OPTI_TYPE_EARLY_SKIP
8008                                | OPTI_TYPE_NOT_ITERATED
8009                                | OPTI_TYPE_APPENDED_SALT
8010                                | OPTI_TYPE_RAW_HASH;
8011                    dgst_pos0   = 3;
8012                    dgst_pos1   = 4;
8013                    dgst_pos2   = 2;
8014                    dgst_pos3   = 1;
8015                    break;
8016
8017       case   131:  hash_type   = HASH_TYPE_SHA1;
8018                    salt_type   = SALT_TYPE_EMBEDDED;
8019                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8020                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8021                                | OPTS_TYPE_PT_UNICODE
8022                                | OPTS_TYPE_PT_UPPER
8023                                | OPTS_TYPE_ST_ADD80
8024                                | OPTS_TYPE_ST_ADDBITS15
8025                                | OPTS_TYPE_ST_HEX;
8026                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8027                    dgst_size   = DGST_SIZE_4_5;
8028                    parse_func  = mssql2000_parse_hash;
8029                    sort_by_digest = sort_by_digest_4_5;
8030                    opti_type   = OPTI_TYPE_ZERO_BYTE
8031                                | OPTI_TYPE_PRECOMPUTE_INIT
8032                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8033                                | OPTI_TYPE_EARLY_SKIP
8034                                | OPTI_TYPE_NOT_ITERATED
8035                                | OPTI_TYPE_APPENDED_SALT
8036                                | OPTI_TYPE_RAW_HASH;
8037                    dgst_pos0   = 3;
8038                    dgst_pos1   = 4;
8039                    dgst_pos2   = 2;
8040                    dgst_pos3   = 1;
8041                    break;
8042
8043       case   132:  hash_type   = HASH_TYPE_SHA1;
8044                    salt_type   = SALT_TYPE_EMBEDDED;
8045                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8047                                | OPTS_TYPE_PT_UNICODE
8048                                | OPTS_TYPE_ST_ADD80
8049                                | OPTS_TYPE_ST_ADDBITS15
8050                                | OPTS_TYPE_ST_HEX;
8051                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8052                    dgst_size   = DGST_SIZE_4_5;
8053                    parse_func  = mssql2005_parse_hash;
8054                    sort_by_digest = sort_by_digest_4_5;
8055                    opti_type   = OPTI_TYPE_ZERO_BYTE
8056                                | OPTI_TYPE_PRECOMPUTE_INIT
8057                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8058                                | OPTI_TYPE_EARLY_SKIP
8059                                | OPTI_TYPE_NOT_ITERATED
8060                                | OPTI_TYPE_APPENDED_SALT
8061                                | OPTI_TYPE_RAW_HASH;
8062                    dgst_pos0   = 3;
8063                    dgst_pos1   = 4;
8064                    dgst_pos2   = 2;
8065                    dgst_pos3   = 1;
8066                    break;
8067
8068       case   133:  hash_type   = HASH_TYPE_SHA1;
8069                    salt_type   = SALT_TYPE_EMBEDDED;
8070                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8072                                | OPTS_TYPE_PT_UNICODE
8073                                | OPTS_TYPE_ST_ADD80
8074                                | OPTS_TYPE_ST_ADDBITS15;
8075                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8076                    dgst_size   = DGST_SIZE_4_5;
8077                    parse_func  = peoplesoft_parse_hash;
8078                    sort_by_digest = sort_by_digest_4_5;
8079                    opti_type   = OPTI_TYPE_ZERO_BYTE
8080                                | OPTI_TYPE_PRECOMPUTE_INIT
8081                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8082                                | OPTI_TYPE_EARLY_SKIP
8083                                | OPTI_TYPE_NOT_ITERATED
8084                                | OPTI_TYPE_APPENDED_SALT
8085                                | OPTI_TYPE_RAW_HASH;
8086                    dgst_pos0   = 3;
8087                    dgst_pos1   = 4;
8088                    dgst_pos2   = 2;
8089                    dgst_pos3   = 1;
8090                    break;
8091
8092       case   140:  hash_type   = HASH_TYPE_SHA1;
8093                    salt_type   = SALT_TYPE_INTERN;
8094                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8096                                | OPTS_TYPE_PT_ADD80
8097                                | OPTS_TYPE_PT_ADDBITS15
8098                                | OPTS_TYPE_PT_UNICODE;
8099                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8100                    dgst_size   = DGST_SIZE_4_5;
8101                    parse_func  = sha1s_parse_hash;
8102                    sort_by_digest = sort_by_digest_4_5;
8103                    opti_type   = OPTI_TYPE_ZERO_BYTE
8104                                | OPTI_TYPE_PRECOMPUTE_INIT
8105                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8106                                | OPTI_TYPE_EARLY_SKIP
8107                                | OPTI_TYPE_NOT_ITERATED
8108                                | OPTI_TYPE_PREPENDED_SALT
8109                                | OPTI_TYPE_RAW_HASH;
8110                    dgst_pos0   = 3;
8111                    dgst_pos1   = 4;
8112                    dgst_pos2   = 2;
8113                    dgst_pos3   = 1;
8114                    break;
8115
8116       case   141:  hash_type   = HASH_TYPE_SHA1;
8117                    salt_type   = SALT_TYPE_EMBEDDED;
8118                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8119                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8120                                | OPTS_TYPE_PT_ADD80
8121                                | OPTS_TYPE_PT_ADDBITS15
8122                                | OPTS_TYPE_PT_UNICODE
8123                                | OPTS_TYPE_ST_BASE64;
8124                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8125                    dgst_size   = DGST_SIZE_4_5;
8126                    parse_func  = episerver_parse_hash;
8127                    sort_by_digest = sort_by_digest_4_5;
8128                    opti_type   = OPTI_TYPE_ZERO_BYTE
8129                                | OPTI_TYPE_PRECOMPUTE_INIT
8130                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8131                                | OPTI_TYPE_EARLY_SKIP
8132                                | OPTI_TYPE_NOT_ITERATED
8133                                | OPTI_TYPE_PREPENDED_SALT
8134                                | OPTI_TYPE_RAW_HASH;
8135                    dgst_pos0   = 3;
8136                    dgst_pos1   = 4;
8137                    dgst_pos2   = 2;
8138                    dgst_pos3   = 1;
8139                    break;
8140
8141       case   150:  hash_type   = HASH_TYPE_SHA1;
8142                    salt_type   = SALT_TYPE_INTERN;
8143                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8144                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8145                                | OPTS_TYPE_ST_ADD80
8146                                | OPTS_TYPE_ST_ADDBITS15;
8147                    kern_type   = KERN_TYPE_HMACSHA1_PW;
8148                    dgst_size   = DGST_SIZE_4_5;
8149                    parse_func  = hmacsha1_parse_hash;
8150                    sort_by_digest = sort_by_digest_4_5;
8151                    opti_type   = OPTI_TYPE_ZERO_BYTE
8152                                | OPTI_TYPE_NOT_ITERATED;
8153                    dgst_pos0   = 3;
8154                    dgst_pos1   = 4;
8155                    dgst_pos2   = 2;
8156                    dgst_pos3   = 1;
8157                    break;
8158
8159       case   160:  hash_type   = HASH_TYPE_SHA1;
8160                    salt_type   = SALT_TYPE_INTERN;
8161                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8163                                | OPTS_TYPE_PT_ADD80
8164                                | OPTS_TYPE_PT_ADDBITS15;
8165                    kern_type   = KERN_TYPE_HMACSHA1_SLT;
8166                    dgst_size   = DGST_SIZE_4_5;
8167                    parse_func  = hmacsha1_parse_hash;
8168                    sort_by_digest = sort_by_digest_4_5;
8169                    opti_type   = OPTI_TYPE_ZERO_BYTE
8170                                | OPTI_TYPE_NOT_ITERATED;
8171                    dgst_pos0   = 3;
8172                    dgst_pos1   = 4;
8173                    dgst_pos2   = 2;
8174                    dgst_pos3   = 1;
8175                    break;
8176
8177       case   200:  hash_type   = HASH_TYPE_MYSQL;
8178                    salt_type   = SALT_TYPE_NONE;
8179                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180                    opts_type   = 0;
8181                    kern_type   = KERN_TYPE_MYSQL;
8182                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8183                    parse_func  = mysql323_parse_hash;
8184                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8185                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8186                    dgst_pos0   = 0;
8187                    dgst_pos1   = 1;
8188                    dgst_pos2   = 2;
8189                    dgst_pos3   = 3;
8190                    break;
8191
8192       case   300:  hash_type   = HASH_TYPE_SHA1;
8193                    salt_type   = SALT_TYPE_NONE;
8194                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8196                                | OPTS_TYPE_PT_ADD80
8197                                | OPTS_TYPE_PT_ADDBITS15;
8198                    kern_type   = KERN_TYPE_MYSQL41;
8199                    dgst_size   = DGST_SIZE_4_5;
8200                    parse_func  = sha1_parse_hash;
8201                    sort_by_digest = sort_by_digest_4_5;
8202                    opti_type   = OPTI_TYPE_ZERO_BYTE
8203                                | OPTI_TYPE_PRECOMPUTE_INIT
8204                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8205                                | OPTI_TYPE_EARLY_SKIP
8206                                | OPTI_TYPE_NOT_ITERATED
8207                                | OPTI_TYPE_NOT_SALTED;
8208                    dgst_pos0   = 3;
8209                    dgst_pos1   = 4;
8210                    dgst_pos2   = 2;
8211                    dgst_pos3   = 1;
8212                    break;
8213
8214       case   400:  hash_type   = HASH_TYPE_MD5;
8215                    salt_type   = SALT_TYPE_EMBEDDED;
8216                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8217                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8218                    kern_type   = KERN_TYPE_PHPASS;
8219                    dgst_size   = DGST_SIZE_4_4;
8220                    parse_func  = phpass_parse_hash;
8221                    sort_by_digest = sort_by_digest_4_4;
8222                    opti_type   = OPTI_TYPE_ZERO_BYTE
8223                                | OPTI_TYPE_SLOW_HASH_SIMD;
8224                    dgst_pos0   = 0;
8225                    dgst_pos1   = 1;
8226                    dgst_pos2   = 2;
8227                    dgst_pos3   = 3;
8228                    break;
8229
8230       case   500:  hash_type   = HASH_TYPE_MD5;
8231                    salt_type   = SALT_TYPE_EMBEDDED;
8232                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8233                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8234                    kern_type   = KERN_TYPE_MD5CRYPT;
8235                    dgst_size   = DGST_SIZE_4_4;
8236                    parse_func  = md5crypt_parse_hash;
8237                    sort_by_digest = sort_by_digest_4_4;
8238                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8239                    dgst_pos0   = 0;
8240                    dgst_pos1   = 1;
8241                    dgst_pos2   = 2;
8242                    dgst_pos3   = 3;
8243                    break;
8244
8245       case   501:  hash_type   = HASH_TYPE_MD5;
8246                    salt_type   = SALT_TYPE_EMBEDDED;
8247                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8248                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8249                                | OPTS_TYPE_HASH_COPY;
8250                    kern_type   = KERN_TYPE_MD5CRYPT;
8251                    dgst_size   = DGST_SIZE_4_4;
8252                    parse_func  = juniper_parse_hash;
8253                    sort_by_digest = sort_by_digest_4_4;
8254                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8255                    dgst_pos0   = 0;
8256                    dgst_pos1   = 1;
8257                    dgst_pos2   = 2;
8258                    dgst_pos3   = 3;
8259                    break;
8260
8261       case   900:  hash_type   = HASH_TYPE_MD4;
8262                    salt_type   = SALT_TYPE_NONE;
8263                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8265                                | OPTS_TYPE_PT_ADD80
8266                                | OPTS_TYPE_PT_ADDBITS14;
8267                    kern_type   = KERN_TYPE_MD4;
8268                    dgst_size   = DGST_SIZE_4_4;
8269                    parse_func  = md4_parse_hash;
8270                    sort_by_digest = sort_by_digest_4_4;
8271                    opti_type   = OPTI_TYPE_ZERO_BYTE
8272                                | OPTI_TYPE_PRECOMPUTE_INIT
8273                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8274                                | OPTI_TYPE_MEET_IN_MIDDLE
8275                                | OPTI_TYPE_EARLY_SKIP
8276                                | OPTI_TYPE_NOT_ITERATED
8277                                | OPTI_TYPE_NOT_SALTED
8278                                | OPTI_TYPE_RAW_HASH;
8279                    dgst_pos0   = 0;
8280                    dgst_pos1   = 3;
8281                    dgst_pos2   = 2;
8282                    dgst_pos3   = 1;
8283                    break;
8284
8285       case  1000:  hash_type   = HASH_TYPE_MD4;
8286                    salt_type   = SALT_TYPE_NONE;
8287                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8289                                | OPTS_TYPE_PT_ADD80
8290                                | OPTS_TYPE_PT_ADDBITS14
8291                                | OPTS_TYPE_PT_UNICODE;
8292                    kern_type   = KERN_TYPE_MD4_PWU;
8293                    dgst_size   = DGST_SIZE_4_4;
8294                    parse_func  = md4_parse_hash;
8295                    sort_by_digest = sort_by_digest_4_4;
8296                    opti_type   = OPTI_TYPE_ZERO_BYTE
8297                                | OPTI_TYPE_PRECOMPUTE_INIT
8298                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8299                                | OPTI_TYPE_MEET_IN_MIDDLE
8300                                | OPTI_TYPE_EARLY_SKIP
8301                                | OPTI_TYPE_NOT_ITERATED
8302                                | OPTI_TYPE_NOT_SALTED
8303                                | OPTI_TYPE_RAW_HASH;
8304                    dgst_pos0   = 0;
8305                    dgst_pos1   = 3;
8306                    dgst_pos2   = 2;
8307                    dgst_pos3   = 1;
8308                    break;
8309
8310       case  1100:  hash_type   = HASH_TYPE_MD4;
8311                    salt_type   = SALT_TYPE_INTERN;
8312                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8314                                | OPTS_TYPE_PT_ADD80
8315                                | OPTS_TYPE_PT_ADDBITS14
8316                                | OPTS_TYPE_PT_UNICODE
8317                                | OPTS_TYPE_ST_ADD80
8318                                | OPTS_TYPE_ST_UNICODE
8319                                | OPTS_TYPE_ST_LOWER;
8320                    kern_type   = KERN_TYPE_MD44_PWUSLT;
8321                    dgst_size   = DGST_SIZE_4_4;
8322                    parse_func  = dcc_parse_hash;
8323                    sort_by_digest = sort_by_digest_4_4;
8324                    opti_type   = OPTI_TYPE_ZERO_BYTE
8325                                | OPTI_TYPE_PRECOMPUTE_INIT
8326                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8327                                | OPTI_TYPE_EARLY_SKIP
8328                                | OPTI_TYPE_NOT_ITERATED;
8329                    dgst_pos0   = 0;
8330                    dgst_pos1   = 3;
8331                    dgst_pos2   = 2;
8332                    dgst_pos3   = 1;
8333                    break;
8334
8335       case  1400:  hash_type   = HASH_TYPE_SHA256;
8336                    salt_type   = SALT_TYPE_NONE;
8337                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8339                                | OPTS_TYPE_PT_ADD80
8340                                | OPTS_TYPE_PT_ADDBITS15;
8341                    kern_type   = KERN_TYPE_SHA256;
8342                    dgst_size   = DGST_SIZE_4_8;
8343                    parse_func  = sha256_parse_hash;
8344                    sort_by_digest = sort_by_digest_4_8;
8345                    opti_type   = OPTI_TYPE_ZERO_BYTE
8346                                | OPTI_TYPE_PRECOMPUTE_INIT
8347                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8348                                | OPTI_TYPE_EARLY_SKIP
8349                                | OPTI_TYPE_NOT_ITERATED
8350                                | OPTI_TYPE_NOT_SALTED
8351                                | OPTI_TYPE_RAW_HASH;
8352                    dgst_pos0   = 3;
8353                    dgst_pos1   = 7;
8354                    dgst_pos2   = 2;
8355                    dgst_pos3   = 6;
8356                    break;
8357
8358       case  1410:  hash_type   = HASH_TYPE_SHA256;
8359                    salt_type   = SALT_TYPE_INTERN;
8360                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8362                                | OPTS_TYPE_ST_ADD80
8363                                | OPTS_TYPE_ST_ADDBITS15;
8364                    kern_type   = KERN_TYPE_SHA256_PWSLT;
8365                    dgst_size   = DGST_SIZE_4_8;
8366                    parse_func  = sha256s_parse_hash;
8367                    sort_by_digest = sort_by_digest_4_8;
8368                    opti_type   = OPTI_TYPE_ZERO_BYTE
8369                                | OPTI_TYPE_PRECOMPUTE_INIT
8370                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8371                                | OPTI_TYPE_EARLY_SKIP
8372                                | OPTI_TYPE_NOT_ITERATED
8373                                | OPTI_TYPE_APPENDED_SALT
8374                                | OPTI_TYPE_RAW_HASH;
8375                    dgst_pos0   = 3;
8376                    dgst_pos1   = 7;
8377                    dgst_pos2   = 2;
8378                    dgst_pos3   = 6;
8379                    break;
8380
8381       case  1420:  hash_type   = HASH_TYPE_SHA256;
8382                    salt_type   = SALT_TYPE_INTERN;
8383                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8385                                | OPTS_TYPE_PT_ADD80
8386                                | OPTS_TYPE_PT_ADDBITS15;
8387                    kern_type   = KERN_TYPE_SHA256_SLTPW;
8388                    dgst_size   = DGST_SIZE_4_8;
8389                    parse_func  = sha256s_parse_hash;
8390                    sort_by_digest = sort_by_digest_4_8;
8391                    opti_type   = OPTI_TYPE_ZERO_BYTE
8392                                | OPTI_TYPE_PRECOMPUTE_INIT
8393                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8394                                | OPTI_TYPE_EARLY_SKIP
8395                                | OPTI_TYPE_NOT_ITERATED
8396                                | OPTI_TYPE_PREPENDED_SALT
8397                                | OPTI_TYPE_RAW_HASH;
8398                    dgst_pos0   = 3;
8399                    dgst_pos1   = 7;
8400                    dgst_pos2   = 2;
8401                    dgst_pos3   = 6;
8402                    break;
8403
8404       case  1421:  hash_type   = HASH_TYPE_SHA256;
8405                    salt_type   = SALT_TYPE_EMBEDDED;
8406                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8408                                | OPTS_TYPE_PT_ADD80
8409                                | OPTS_TYPE_PT_ADDBITS15;
8410                    kern_type   = KERN_TYPE_SHA256_SLTPW;
8411                    dgst_size   = DGST_SIZE_4_8;
8412                    parse_func  = hmailserver_parse_hash;
8413                    sort_by_digest = sort_by_digest_4_8;
8414                    opti_type   = OPTI_TYPE_ZERO_BYTE
8415                                | OPTI_TYPE_PRECOMPUTE_INIT
8416                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8417                                | OPTI_TYPE_EARLY_SKIP
8418                                | OPTI_TYPE_NOT_ITERATED
8419                                | OPTI_TYPE_PREPENDED_SALT
8420                                | OPTI_TYPE_RAW_HASH;
8421                    dgst_pos0   = 3;
8422                    dgst_pos1   = 7;
8423                    dgst_pos2   = 2;
8424                    dgst_pos3   = 6;
8425                    break;
8426
8427       case  1430:  hash_type   = HASH_TYPE_SHA256;
8428                    salt_type   = SALT_TYPE_INTERN;
8429                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8430                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8431                                | OPTS_TYPE_PT_UNICODE
8432                                | OPTS_TYPE_ST_ADD80
8433                                | OPTS_TYPE_ST_ADDBITS15;
8434                    kern_type   = KERN_TYPE_SHA256_PWUSLT;
8435                    dgst_size   = DGST_SIZE_4_8;
8436                    parse_func  = sha256s_parse_hash;
8437                    sort_by_digest = sort_by_digest_4_8;
8438                    opti_type   = OPTI_TYPE_ZERO_BYTE
8439                                | OPTI_TYPE_PRECOMPUTE_INIT
8440                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8441                                | OPTI_TYPE_EARLY_SKIP
8442                                | OPTI_TYPE_NOT_ITERATED
8443                                | OPTI_TYPE_APPENDED_SALT
8444                                | OPTI_TYPE_RAW_HASH;
8445                    dgst_pos0   = 3;
8446                    dgst_pos1   = 7;
8447                    dgst_pos2   = 2;
8448                    dgst_pos3   = 6;
8449                    break;
8450
8451       case  1440:  hash_type   = HASH_TYPE_SHA256;
8452                    salt_type   = SALT_TYPE_INTERN;
8453                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8455                                | OPTS_TYPE_PT_ADD80
8456                                | OPTS_TYPE_PT_ADDBITS15
8457                                | OPTS_TYPE_PT_UNICODE;
8458                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8459                    dgst_size   = DGST_SIZE_4_8;
8460                    parse_func  = sha256s_parse_hash;
8461                    sort_by_digest = sort_by_digest_4_8;
8462                    opti_type   = OPTI_TYPE_ZERO_BYTE
8463                                | OPTI_TYPE_PRECOMPUTE_INIT
8464                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8465                                | OPTI_TYPE_EARLY_SKIP
8466                                | OPTI_TYPE_NOT_ITERATED
8467                                | OPTI_TYPE_PREPENDED_SALT
8468                                | OPTI_TYPE_RAW_HASH;
8469                    dgst_pos0   = 3;
8470                    dgst_pos1   = 7;
8471                    dgst_pos2   = 2;
8472                    dgst_pos3   = 6;
8473                    break;
8474
8475       case  1441:  hash_type   = HASH_TYPE_SHA256;
8476                    salt_type   = SALT_TYPE_EMBEDDED;
8477                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8478                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8479                                | OPTS_TYPE_PT_ADD80
8480                                | OPTS_TYPE_PT_ADDBITS15
8481                                | OPTS_TYPE_PT_UNICODE
8482                                | OPTS_TYPE_ST_BASE64;
8483                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8484                    dgst_size   = DGST_SIZE_4_8;
8485                    parse_func  = episerver4_parse_hash;
8486                    sort_by_digest = sort_by_digest_4_8;
8487                    opti_type   = OPTI_TYPE_ZERO_BYTE
8488                                | OPTI_TYPE_PRECOMPUTE_INIT
8489                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8490                                | OPTI_TYPE_EARLY_SKIP
8491                                | OPTI_TYPE_NOT_ITERATED
8492                                | OPTI_TYPE_PREPENDED_SALT
8493                                | OPTI_TYPE_RAW_HASH;
8494                    dgst_pos0   = 3;
8495                    dgst_pos1   = 7;
8496                    dgst_pos2   = 2;
8497                    dgst_pos3   = 6;
8498                    break;
8499
8500       case  1450:  hash_type   = HASH_TYPE_SHA256;
8501                    salt_type   = SALT_TYPE_INTERN;
8502                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8504                                | OPTS_TYPE_ST_ADD80;
8505                    kern_type   = KERN_TYPE_HMACSHA256_PW;
8506                    dgst_size   = DGST_SIZE_4_8;
8507                    parse_func  = hmacsha256_parse_hash;
8508                    sort_by_digest = sort_by_digest_4_8;
8509                    opti_type   = OPTI_TYPE_ZERO_BYTE
8510                                | OPTI_TYPE_NOT_ITERATED;
8511                    dgst_pos0   = 3;
8512                    dgst_pos1   = 7;
8513                    dgst_pos2   = 2;
8514                    dgst_pos3   = 6;
8515                    break;
8516
8517       case  1460:  hash_type   = HASH_TYPE_SHA256;
8518                    salt_type   = SALT_TYPE_INTERN;
8519                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8520                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8521                                | OPTS_TYPE_PT_ADD80
8522                                | OPTS_TYPE_PT_ADDBITS15;
8523                    kern_type   = KERN_TYPE_HMACSHA256_SLT;
8524                    dgst_size   = DGST_SIZE_4_8;
8525                    parse_func  = hmacsha256_parse_hash;
8526                    sort_by_digest = sort_by_digest_4_8;
8527                    opti_type   = OPTI_TYPE_ZERO_BYTE
8528                                | OPTI_TYPE_NOT_ITERATED;
8529                    dgst_pos0   = 3;
8530                    dgst_pos1   = 7;
8531                    dgst_pos2   = 2;
8532                    dgst_pos3   = 6;
8533                    break;
8534
8535       case  1500:  hash_type   = HASH_TYPE_DESCRYPT;
8536                    salt_type   = SALT_TYPE_EMBEDDED;
8537                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8538                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8539                                | OPTS_TYPE_PT_BITSLICE;
8540                    kern_type   = KERN_TYPE_DESCRYPT;
8541                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8542                    parse_func  = descrypt_parse_hash;
8543                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8544                    opti_type   = OPTI_TYPE_ZERO_BYTE
8545                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
8546                    dgst_pos0   = 0;
8547                    dgst_pos1   = 1;
8548                    dgst_pos2   = 2;
8549                    dgst_pos3   = 3;
8550                    break;
8551
8552       case  1600:  hash_type   = HASH_TYPE_MD5;
8553                    salt_type   = SALT_TYPE_EMBEDDED;
8554                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8555                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8556                    kern_type   = KERN_TYPE_APR1CRYPT;
8557                    dgst_size   = DGST_SIZE_4_4;
8558                    parse_func  = md5apr1_parse_hash;
8559                    sort_by_digest = sort_by_digest_4_4;
8560                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8561                    dgst_pos0   = 0;
8562                    dgst_pos1   = 1;
8563                    dgst_pos2   = 2;
8564                    dgst_pos3   = 3;
8565                    break;
8566
8567       case  1700:  hash_type   = HASH_TYPE_SHA512;
8568                    salt_type   = SALT_TYPE_NONE;
8569                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8571                                | OPTS_TYPE_PT_ADD80
8572                                | OPTS_TYPE_PT_ADDBITS15;
8573                    kern_type   = KERN_TYPE_SHA512;
8574                    dgst_size   = DGST_SIZE_8_8;
8575                    parse_func  = sha512_parse_hash;
8576                    sort_by_digest = sort_by_digest_8_8;
8577                    opti_type   = OPTI_TYPE_ZERO_BYTE
8578                                | OPTI_TYPE_PRECOMPUTE_INIT
8579                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8580                                | OPTI_TYPE_EARLY_SKIP
8581                                | OPTI_TYPE_NOT_ITERATED
8582                                | OPTI_TYPE_NOT_SALTED
8583                                | OPTI_TYPE_USES_BITS_64
8584                                | OPTI_TYPE_RAW_HASH;
8585                    dgst_pos0   = 14;
8586                    dgst_pos1   = 15;
8587                    dgst_pos2   = 6;
8588                    dgst_pos3   = 7;
8589                    break;
8590
8591       case  1710:  hash_type   = HASH_TYPE_SHA512;
8592                    salt_type   = SALT_TYPE_INTERN;
8593                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8595                                | OPTS_TYPE_ST_ADD80
8596                                | OPTS_TYPE_ST_ADDBITS15;
8597                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8598                    dgst_size   = DGST_SIZE_8_8;
8599                    parse_func  = sha512s_parse_hash;
8600                    sort_by_digest = sort_by_digest_8_8;
8601                    opti_type   = OPTI_TYPE_ZERO_BYTE
8602                                | OPTI_TYPE_PRECOMPUTE_INIT
8603                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8604                                | OPTI_TYPE_EARLY_SKIP
8605                                | OPTI_TYPE_NOT_ITERATED
8606                                | OPTI_TYPE_APPENDED_SALT
8607                                | OPTI_TYPE_USES_BITS_64
8608                                | OPTI_TYPE_RAW_HASH;
8609                    dgst_pos0   = 14;
8610                    dgst_pos1   = 15;
8611                    dgst_pos2   = 6;
8612                    dgst_pos3   = 7;
8613                    break;
8614
8615       case  1711:  hash_type   = HASH_TYPE_SHA512;
8616                    salt_type   = SALT_TYPE_EMBEDDED;
8617                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8619                                | OPTS_TYPE_ST_ADD80
8620                                | OPTS_TYPE_ST_ADDBITS15;
8621                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8622                    dgst_size   = DGST_SIZE_8_8;
8623                    parse_func  = sha512b64s_parse_hash;
8624                    sort_by_digest = sort_by_digest_8_8;
8625                    opti_type   = OPTI_TYPE_ZERO_BYTE
8626                                | OPTI_TYPE_PRECOMPUTE_INIT
8627                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8628                                | OPTI_TYPE_EARLY_SKIP
8629                                | OPTI_TYPE_NOT_ITERATED
8630                                | OPTI_TYPE_APPENDED_SALT
8631                                | OPTI_TYPE_USES_BITS_64
8632                                | OPTI_TYPE_RAW_HASH;
8633                    dgst_pos0   = 14;
8634                    dgst_pos1   = 15;
8635                    dgst_pos2   = 6;
8636                    dgst_pos3   = 7;
8637                    break;
8638
8639       case  1720:  hash_type   = HASH_TYPE_SHA512;
8640                    salt_type   = SALT_TYPE_INTERN;
8641                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8642                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8643                                | OPTS_TYPE_PT_ADD80
8644                                | OPTS_TYPE_PT_ADDBITS15;
8645                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8646                    dgst_size   = DGST_SIZE_8_8;
8647                    parse_func  = sha512s_parse_hash;
8648                    sort_by_digest = sort_by_digest_8_8;
8649                    opti_type   = OPTI_TYPE_ZERO_BYTE
8650                                | OPTI_TYPE_PRECOMPUTE_INIT
8651                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8652                                | OPTI_TYPE_EARLY_SKIP
8653                                | OPTI_TYPE_NOT_ITERATED
8654                                | OPTI_TYPE_PREPENDED_SALT
8655                                | OPTI_TYPE_USES_BITS_64
8656                                | OPTI_TYPE_RAW_HASH;
8657                    dgst_pos0   = 14;
8658                    dgst_pos1   = 15;
8659                    dgst_pos2   = 6;
8660                    dgst_pos3   = 7;
8661                    break;
8662
8663       case  1722:  hash_type   = HASH_TYPE_SHA512;
8664                    salt_type   = SALT_TYPE_EMBEDDED;
8665                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8667                                | OPTS_TYPE_PT_ADD80
8668                                | OPTS_TYPE_PT_ADDBITS15
8669                                | OPTS_TYPE_ST_HEX;
8670                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8671                    dgst_size   = DGST_SIZE_8_8;
8672                    parse_func  = osx512_parse_hash;
8673                    sort_by_digest = sort_by_digest_8_8;
8674                    opti_type   = OPTI_TYPE_ZERO_BYTE
8675                                | OPTI_TYPE_PRECOMPUTE_INIT
8676                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8677                                | OPTI_TYPE_EARLY_SKIP
8678                                | OPTI_TYPE_NOT_ITERATED
8679                                | OPTI_TYPE_PREPENDED_SALT
8680                                | OPTI_TYPE_USES_BITS_64
8681                                | OPTI_TYPE_RAW_HASH;
8682                    dgst_pos0   = 14;
8683                    dgst_pos1   = 15;
8684                    dgst_pos2   = 6;
8685                    dgst_pos3   = 7;
8686                    break;
8687
8688       case  1730:  hash_type   = HASH_TYPE_SHA512;
8689                    salt_type   = SALT_TYPE_INTERN;
8690                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8692                                | OPTS_TYPE_PT_UNICODE
8693                                | OPTS_TYPE_ST_ADD80
8694                                | OPTS_TYPE_ST_ADDBITS15;
8695                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
8696                    dgst_size   = DGST_SIZE_8_8;
8697                    parse_func  = sha512s_parse_hash;
8698                    sort_by_digest = sort_by_digest_8_8;
8699                    opti_type   = OPTI_TYPE_ZERO_BYTE
8700                                | OPTI_TYPE_PRECOMPUTE_INIT
8701                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8702                                | OPTI_TYPE_EARLY_SKIP
8703                                | OPTI_TYPE_NOT_ITERATED
8704                                | OPTI_TYPE_APPENDED_SALT
8705                                | OPTI_TYPE_USES_BITS_64
8706                                | OPTI_TYPE_RAW_HASH;
8707                    dgst_pos0   = 14;
8708                    dgst_pos1   = 15;
8709                    dgst_pos2   = 6;
8710                    dgst_pos3   = 7;
8711                    break;
8712
8713       case  1731:  hash_type   = HASH_TYPE_SHA512;
8714                    salt_type   = SALT_TYPE_EMBEDDED;
8715                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8716                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8717                                | OPTS_TYPE_PT_UNICODE
8718                                | OPTS_TYPE_ST_ADD80
8719                                | OPTS_TYPE_ST_ADDBITS15
8720                                | OPTS_TYPE_ST_HEX;
8721                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
8722                    dgst_size   = DGST_SIZE_8_8;
8723                    parse_func  = mssql2012_parse_hash;
8724                    sort_by_digest = sort_by_digest_8_8;
8725                    opti_type   = OPTI_TYPE_ZERO_BYTE
8726                                | OPTI_TYPE_PRECOMPUTE_INIT
8727                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8728                                | OPTI_TYPE_EARLY_SKIP
8729                                | OPTI_TYPE_NOT_ITERATED
8730                                | OPTI_TYPE_APPENDED_SALT
8731                                | OPTI_TYPE_USES_BITS_64
8732                                | OPTI_TYPE_RAW_HASH;
8733                    dgst_pos0   = 14;
8734                    dgst_pos1   = 15;
8735                    dgst_pos2   = 6;
8736                    dgst_pos3   = 7;
8737                    break;
8738
8739       case  1740:  hash_type   = HASH_TYPE_SHA512;
8740                    salt_type   = SALT_TYPE_INTERN;
8741                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8742                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8743                                | OPTS_TYPE_PT_ADD80
8744                                | OPTS_TYPE_PT_ADDBITS15
8745                                | OPTS_TYPE_PT_UNICODE;
8746                    kern_type   = KERN_TYPE_SHA512_SLTPWU;
8747                    dgst_size   = DGST_SIZE_8_8;
8748                    parse_func  = sha512s_parse_hash;
8749                    sort_by_digest = sort_by_digest_8_8;
8750                    opti_type   = OPTI_TYPE_ZERO_BYTE
8751                                | OPTI_TYPE_PRECOMPUTE_INIT
8752                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8753                                | OPTI_TYPE_EARLY_SKIP
8754                                | OPTI_TYPE_NOT_ITERATED
8755                                | OPTI_TYPE_PREPENDED_SALT
8756                                | OPTI_TYPE_USES_BITS_64
8757                                | OPTI_TYPE_RAW_HASH;
8758                    dgst_pos0   = 14;
8759                    dgst_pos1   = 15;
8760                    dgst_pos2   = 6;
8761                    dgst_pos3   = 7;
8762                    break;
8763
8764       case  1750:  hash_type   = HASH_TYPE_SHA512;
8765                    salt_type   = SALT_TYPE_INTERN;
8766                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8768                                | OPTS_TYPE_ST_ADD80;
8769                    kern_type   = KERN_TYPE_HMACSHA512_PW;
8770                    dgst_size   = DGST_SIZE_8_8;
8771                    parse_func  = hmacsha512_parse_hash;
8772                    sort_by_digest = sort_by_digest_8_8;
8773                    opti_type   = OPTI_TYPE_ZERO_BYTE
8774                                | OPTI_TYPE_USES_BITS_64
8775                                | OPTI_TYPE_NOT_ITERATED;
8776                    dgst_pos0   = 14;
8777                    dgst_pos1   = 15;
8778                    dgst_pos2   = 6;
8779                    dgst_pos3   = 7;
8780                    break;
8781
8782       case  1760:  hash_type   = HASH_TYPE_SHA512;
8783                    salt_type   = SALT_TYPE_INTERN;
8784                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8785                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8786                                | OPTS_TYPE_PT_ADD80
8787                                | OPTS_TYPE_PT_ADDBITS15;
8788                    kern_type   = KERN_TYPE_HMACSHA512_SLT;
8789                    dgst_size   = DGST_SIZE_8_8;
8790                    parse_func  = hmacsha512_parse_hash;
8791                    sort_by_digest = sort_by_digest_8_8;
8792                    opti_type   = OPTI_TYPE_ZERO_BYTE
8793                                | OPTI_TYPE_USES_BITS_64
8794                                | OPTI_TYPE_NOT_ITERATED;
8795                    dgst_pos0   = 14;
8796                    dgst_pos1   = 15;
8797                    dgst_pos2   = 6;
8798                    dgst_pos3   = 7;
8799                    break;
8800
8801       case  1800:  hash_type   = HASH_TYPE_SHA512;
8802                    salt_type   = SALT_TYPE_EMBEDDED;
8803                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8805                    kern_type   = KERN_TYPE_SHA512CRYPT;
8806                    dgst_size   = DGST_SIZE_8_8;
8807                    parse_func  = sha512crypt_parse_hash;
8808                    sort_by_digest = sort_by_digest_8_8;
8809                    opti_type   = OPTI_TYPE_ZERO_BYTE
8810                                | OPTI_TYPE_USES_BITS_64;
8811                    dgst_pos0   = 0;
8812                    dgst_pos1   = 1;
8813                    dgst_pos2   = 2;
8814                    dgst_pos3   = 3;
8815                    break;
8816
8817       case  2000:  hash_type   = HASH_TYPE_STDOUT;
8818                    salt_type   = SALT_TYPE_NONE;
8819                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8821                    kern_type   = KERN_TYPE_STDOUT;
8822                    dgst_size   = DGST_SIZE_4_4;
8823                    parse_func  = NULL;
8824                    sort_by_digest = NULL;
8825                    opti_type   = 0;
8826                    dgst_pos0   = 0;
8827                    dgst_pos1   = 0;
8828                    dgst_pos2   = 0;
8829                    dgst_pos3   = 0;
8830                    break;
8831
8832       case  2100:  hash_type   = HASH_TYPE_DCC2;
8833                    salt_type   = SALT_TYPE_EMBEDDED;
8834                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8835                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
8836                                | OPTS_TYPE_ST_LOWER
8837                                | OPTS_TYPE_ST_UNICODE;
8838                    kern_type   = KERN_TYPE_DCC2;
8839                    dgst_size   = DGST_SIZE_4_4;
8840                    parse_func  = dcc2_parse_hash;
8841                    sort_by_digest = sort_by_digest_4_4;
8842                    opti_type   = OPTI_TYPE_ZERO_BYTE
8843                                | OPTI_TYPE_SLOW_HASH_SIMD;
8844                    dgst_pos0   = 0;
8845                    dgst_pos1   = 1;
8846                    dgst_pos2   = 2;
8847                    dgst_pos3   = 3;
8848                    break;
8849
8850       case  2400:  hash_type   = HASH_TYPE_MD5;
8851                    salt_type   = SALT_TYPE_NONE;
8852                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8853                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8854                    kern_type   = KERN_TYPE_MD5PIX;
8855                    dgst_size   = DGST_SIZE_4_4;
8856                    parse_func  = md5pix_parse_hash;
8857                    sort_by_digest = sort_by_digest_4_4;
8858                    opti_type   = OPTI_TYPE_ZERO_BYTE
8859                                | OPTI_TYPE_PRECOMPUTE_INIT
8860                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8861                                | OPTI_TYPE_EARLY_SKIP
8862                                | OPTI_TYPE_NOT_ITERATED
8863                                | OPTI_TYPE_NOT_SALTED;
8864                    dgst_pos0   = 0;
8865                    dgst_pos1   = 3;
8866                    dgst_pos2   = 2;
8867                    dgst_pos3   = 1;
8868                    break;
8869
8870       case  2410:  hash_type   = HASH_TYPE_MD5;
8871                    salt_type   = SALT_TYPE_INTERN;
8872                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8873                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8874                    kern_type   = KERN_TYPE_MD5ASA;
8875                    dgst_size   = DGST_SIZE_4_4;
8876                    parse_func  = md5asa_parse_hash;
8877                    sort_by_digest = sort_by_digest_4_4;
8878                    opti_type   = OPTI_TYPE_ZERO_BYTE
8879                                | OPTI_TYPE_PRECOMPUTE_INIT
8880                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8881                                | OPTI_TYPE_EARLY_SKIP
8882                                | OPTI_TYPE_NOT_ITERATED;
8883                    dgst_pos0   = 0;
8884                    dgst_pos1   = 3;
8885                    dgst_pos2   = 2;
8886                    dgst_pos3   = 1;
8887                    break;
8888
8889       case  2500:  hash_type   = HASH_TYPE_WPA;
8890                    salt_type   = SALT_TYPE_EMBEDDED;
8891                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8892                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8893                    kern_type   = KERN_TYPE_WPA;
8894                    dgst_size   = DGST_SIZE_4_4;
8895                    parse_func  = wpa_parse_hash;
8896                    sort_by_digest = sort_by_digest_4_4;
8897                    opti_type   = OPTI_TYPE_ZERO_BYTE
8898                                | OPTI_TYPE_SLOW_HASH_SIMD;
8899                    dgst_pos0   = 0;
8900                    dgst_pos1   = 1;
8901                    dgst_pos2   = 2;
8902                    dgst_pos3   = 3;
8903                    break;
8904
8905       case  2600:  hash_type   = HASH_TYPE_MD5;
8906                    salt_type   = SALT_TYPE_VIRTUAL;
8907                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8909                                | OPTS_TYPE_PT_ADD80
8910                                | OPTS_TYPE_PT_ADDBITS14
8911                                | OPTS_TYPE_ST_ADD80;
8912                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8913                    dgst_size   = DGST_SIZE_4_4;
8914                    parse_func  = md5md5_parse_hash;
8915                    sort_by_digest = sort_by_digest_4_4;
8916                    opti_type   = OPTI_TYPE_ZERO_BYTE
8917                                | OPTI_TYPE_PRECOMPUTE_INIT
8918                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8919                                | OPTI_TYPE_EARLY_SKIP;
8920                    dgst_pos0   = 0;
8921                    dgst_pos1   = 3;
8922                    dgst_pos2   = 2;
8923                    dgst_pos3   = 1;
8924                    break;
8925
8926       case  2611:  hash_type   = HASH_TYPE_MD5;
8927                    salt_type   = SALT_TYPE_INTERN;
8928                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8929                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8930                                | OPTS_TYPE_PT_ADD80
8931                                | OPTS_TYPE_PT_ADDBITS14
8932                                | OPTS_TYPE_ST_ADD80;
8933                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8934                    dgst_size   = DGST_SIZE_4_4;
8935                    parse_func  = vb3_parse_hash;
8936                    sort_by_digest = sort_by_digest_4_4;
8937                    opti_type   = OPTI_TYPE_ZERO_BYTE
8938                                | OPTI_TYPE_PRECOMPUTE_INIT
8939                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8940                                | OPTI_TYPE_EARLY_SKIP;
8941                    dgst_pos0   = 0;
8942                    dgst_pos1   = 3;
8943                    dgst_pos2   = 2;
8944                    dgst_pos3   = 1;
8945                    break;
8946
8947       case  2612:  hash_type   = HASH_TYPE_MD5;
8948                    salt_type   = SALT_TYPE_EMBEDDED;
8949                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8950                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8951                                | OPTS_TYPE_PT_ADD80
8952                                | OPTS_TYPE_PT_ADDBITS14
8953                                | OPTS_TYPE_ST_ADD80
8954                                | OPTS_TYPE_ST_HEX;
8955                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8956                    dgst_size   = DGST_SIZE_4_4;
8957                    parse_func  = phps_parse_hash;
8958                    sort_by_digest = sort_by_digest_4_4;
8959                    opti_type   = OPTI_TYPE_ZERO_BYTE
8960                                | OPTI_TYPE_PRECOMPUTE_INIT
8961                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8962                                | OPTI_TYPE_EARLY_SKIP;
8963                    dgst_pos0   = 0;
8964                    dgst_pos1   = 3;
8965                    dgst_pos2   = 2;
8966                    dgst_pos3   = 1;
8967                    break;
8968
8969       case  2711:  hash_type   = HASH_TYPE_MD5;
8970                    salt_type   = SALT_TYPE_INTERN;
8971                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8973                                | OPTS_TYPE_PT_ADD80
8974                                | OPTS_TYPE_PT_ADDBITS14
8975                                | OPTS_TYPE_ST_ADD80;
8976                    kern_type   = KERN_TYPE_MD55_PWSLT2;
8977                    dgst_size   = DGST_SIZE_4_4;
8978                    parse_func  = vb30_parse_hash;
8979                    sort_by_digest = sort_by_digest_4_4;
8980                    opti_type   = OPTI_TYPE_ZERO_BYTE
8981                                | OPTI_TYPE_PRECOMPUTE_INIT
8982                                | OPTI_TYPE_EARLY_SKIP;
8983                    dgst_pos0   = 0;
8984                    dgst_pos1   = 3;
8985                    dgst_pos2   = 2;
8986                    dgst_pos3   = 1;
8987                    break;
8988
8989       case  2811:  hash_type   = HASH_TYPE_MD5;
8990                    salt_type   = SALT_TYPE_INTERN;
8991                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8993                                | OPTS_TYPE_PT_ADD80
8994                                | OPTS_TYPE_PT_ADDBITS14;
8995                    kern_type   = KERN_TYPE_MD55_SLTPW;
8996                    dgst_size   = DGST_SIZE_4_4;
8997                    parse_func  = ipb2_parse_hash;
8998                    sort_by_digest = sort_by_digest_4_4;
8999                    opti_type   = OPTI_TYPE_ZERO_BYTE
9000                                | OPTI_TYPE_PRECOMPUTE_INIT
9001                                | OPTI_TYPE_EARLY_SKIP;
9002                    dgst_pos0   = 0;
9003                    dgst_pos1   = 3;
9004                    dgst_pos2   = 2;
9005                    dgst_pos3   = 1;
9006                    break;
9007
9008       case  3000:  hash_type   = HASH_TYPE_LM;
9009                    salt_type   = SALT_TYPE_NONE;
9010                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9011                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9012                                | OPTS_TYPE_PT_UPPER
9013                                | OPTS_TYPE_PT_BITSLICE;
9014                    kern_type   = KERN_TYPE_LM;
9015                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9016                    parse_func  = lm_parse_hash;
9017                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9018                    opti_type   = OPTI_TYPE_ZERO_BYTE
9019                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9020                    dgst_pos0   = 0;
9021                    dgst_pos1   = 1;
9022                    dgst_pos2   = 2;
9023                    dgst_pos3   = 3;
9024                    break;
9025
9026       case  3100:  hash_type   = HASH_TYPE_ORACLEH;
9027                    salt_type   = SALT_TYPE_INTERN;
9028                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9029                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9030                                | OPTS_TYPE_PT_UPPER
9031                                | OPTS_TYPE_ST_UPPER;
9032                    kern_type   = KERN_TYPE_ORACLEH;
9033                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9034                    parse_func  = oracleh_parse_hash;
9035                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9036                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9037                    dgst_pos0   = 0;
9038                    dgst_pos1   = 1;
9039                    dgst_pos2   = 2;
9040                    dgst_pos3   = 3;
9041                    break;
9042
9043       case  3200:  hash_type   = HASH_TYPE_BCRYPT;
9044                    salt_type   = SALT_TYPE_EMBEDDED;
9045                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9047                                | OPTS_TYPE_ST_GENERATE_LE;
9048                    kern_type   = KERN_TYPE_BCRYPT;
9049                    dgst_size   = DGST_SIZE_4_6;
9050                    parse_func  = bcrypt_parse_hash;
9051                    sort_by_digest = sort_by_digest_4_6;
9052                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9053                    dgst_pos0   = 0;
9054                    dgst_pos1   = 1;
9055                    dgst_pos2   = 2;
9056                    dgst_pos3   = 3;
9057                    break;
9058
9059       case  3710:  hash_type   = HASH_TYPE_MD5;
9060                    salt_type   = SALT_TYPE_INTERN;
9061                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9062                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9063                                | OPTS_TYPE_PT_ADD80
9064                                | OPTS_TYPE_PT_ADDBITS14;
9065                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9066                    dgst_size   = DGST_SIZE_4_4;
9067                    parse_func  = md5s_parse_hash;
9068                    sort_by_digest = sort_by_digest_4_4;
9069                    opti_type   = OPTI_TYPE_ZERO_BYTE
9070                                | OPTI_TYPE_PRECOMPUTE_INIT
9071                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9072                                | OPTI_TYPE_EARLY_SKIP;
9073                    dgst_pos0   = 0;
9074                    dgst_pos1   = 3;
9075                    dgst_pos2   = 2;
9076                    dgst_pos3   = 1;
9077                    break;
9078
9079       case  3711:  hash_type   = HASH_TYPE_MD5;
9080                    salt_type   = SALT_TYPE_EMBEDDED;
9081                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9082                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9083                                | OPTS_TYPE_PT_ADD80
9084                                | OPTS_TYPE_PT_ADDBITS14;
9085                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9086                    dgst_size   = DGST_SIZE_4_4;
9087                    parse_func  = mediawiki_b_parse_hash;
9088                    sort_by_digest = sort_by_digest_4_4;
9089                    opti_type   = OPTI_TYPE_ZERO_BYTE
9090                                | OPTI_TYPE_PRECOMPUTE_INIT
9091                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9092                                | OPTI_TYPE_EARLY_SKIP;
9093                    dgst_pos0   = 0;
9094                    dgst_pos1   = 3;
9095                    dgst_pos2   = 2;
9096                    dgst_pos3   = 1;
9097                    break;
9098
9099       case  3800:  hash_type   = HASH_TYPE_MD5;
9100                    salt_type   = SALT_TYPE_INTERN;
9101                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9103                                | OPTS_TYPE_ST_ADDBITS14;
9104                    kern_type   = KERN_TYPE_MD5_SLT_PW_SLT;
9105                    dgst_size   = DGST_SIZE_4_4;
9106                    parse_func  = md5s_parse_hash;
9107                    sort_by_digest = sort_by_digest_4_4;
9108                    opti_type   = OPTI_TYPE_ZERO_BYTE
9109                                | OPTI_TYPE_PRECOMPUTE_INIT
9110                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9111                                | OPTI_TYPE_EARLY_SKIP
9112                                | OPTI_TYPE_NOT_ITERATED
9113                                | OPTI_TYPE_RAW_HASH;
9114                    dgst_pos0   = 0;
9115                    dgst_pos1   = 3;
9116                    dgst_pos2   = 2;
9117                    dgst_pos3   = 1;
9118                    break;
9119
9120       case  4300:  hash_type   = HASH_TYPE_MD5;
9121                    salt_type   = SALT_TYPE_VIRTUAL;
9122                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9123                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9124                                | OPTS_TYPE_PT_ADD80
9125                                | OPTS_TYPE_PT_ADDBITS14
9126                                | OPTS_TYPE_ST_ADD80;
9127                    kern_type   = KERN_TYPE_MD5U5_PWSLT1;
9128                    dgst_size   = DGST_SIZE_4_4;
9129                    parse_func  = md5md5_parse_hash;
9130                    sort_by_digest = sort_by_digest_4_4;
9131                    opti_type   = OPTI_TYPE_ZERO_BYTE
9132                                | OPTI_TYPE_PRECOMPUTE_INIT
9133                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9134                                | OPTI_TYPE_EARLY_SKIP;
9135                    dgst_pos0   = 0;
9136                    dgst_pos1   = 3;
9137                    dgst_pos2   = 2;
9138                    dgst_pos3   = 1;
9139                    break;
9140
9141
9142       case  4400:  hash_type   = HASH_TYPE_MD5;
9143                    salt_type   = SALT_TYPE_NONE;
9144                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9146                                | OPTS_TYPE_PT_ADD80
9147                                | OPTS_TYPE_PT_ADDBITS15;
9148                    kern_type   = KERN_TYPE_MD5_SHA1;
9149                    dgst_size   = DGST_SIZE_4_4;
9150                    parse_func  = md5_parse_hash;
9151                    sort_by_digest = sort_by_digest_4_4;
9152                    opti_type   = OPTI_TYPE_ZERO_BYTE
9153                                | OPTI_TYPE_PRECOMPUTE_INIT
9154                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9155                                | OPTI_TYPE_EARLY_SKIP
9156                                | OPTI_TYPE_NOT_ITERATED
9157                                | OPTI_TYPE_NOT_SALTED
9158                                | OPTI_TYPE_RAW_HASH;
9159                    dgst_pos0   = 0;
9160                    dgst_pos1   = 3;
9161                    dgst_pos2   = 2;
9162                    dgst_pos3   = 1;
9163                    break;
9164
9165       case  4500:  hash_type   = HASH_TYPE_SHA1;
9166                    salt_type   = SALT_TYPE_NONE;
9167                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9168                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9169                                | OPTS_TYPE_PT_ADD80
9170                                | OPTS_TYPE_PT_ADDBITS15;
9171                    kern_type   = KERN_TYPE_SHA11;
9172                    dgst_size   = DGST_SIZE_4_5;
9173                    parse_func  = sha1_parse_hash;
9174                    sort_by_digest = sort_by_digest_4_5;
9175                    opti_type   = OPTI_TYPE_ZERO_BYTE
9176                                | OPTI_TYPE_PRECOMPUTE_INIT
9177                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9178                                | OPTI_TYPE_EARLY_SKIP
9179                                | OPTI_TYPE_NOT_SALTED;
9180                    dgst_pos0   = 3;
9181                    dgst_pos1   = 4;
9182                    dgst_pos2   = 2;
9183                    dgst_pos3   = 1;
9184                    break;
9185
9186       case  4700:  hash_type   = HASH_TYPE_SHA1;
9187                    salt_type   = SALT_TYPE_NONE;
9188                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9189                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9190                                | OPTS_TYPE_PT_ADD80
9191                                | OPTS_TYPE_PT_ADDBITS14;
9192                    kern_type   = KERN_TYPE_SHA1_MD5;
9193                    dgst_size   = DGST_SIZE_4_5;
9194                    parse_func  = sha1_parse_hash;
9195                    sort_by_digest = sort_by_digest_4_5;
9196                    opti_type   = OPTI_TYPE_ZERO_BYTE
9197                                | OPTI_TYPE_PRECOMPUTE_INIT
9198                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9199                                | OPTI_TYPE_EARLY_SKIP
9200                                | OPTI_TYPE_NOT_ITERATED
9201                                | OPTI_TYPE_NOT_SALTED
9202                                | OPTI_TYPE_RAW_HASH;
9203                    dgst_pos0   = 3;
9204                    dgst_pos1   = 4;
9205                    dgst_pos2   = 2;
9206                    dgst_pos3   = 1;
9207                    break;
9208
9209       case  4800:  hash_type   = HASH_TYPE_MD5;
9210                    salt_type   = SALT_TYPE_EMBEDDED;
9211                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9212                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9213                                | OPTS_TYPE_PT_ADDBITS14;
9214                    kern_type   = KERN_TYPE_MD5_CHAP;
9215                    dgst_size   = DGST_SIZE_4_4;
9216                    parse_func  = chap_parse_hash;
9217                    sort_by_digest = sort_by_digest_4_4;
9218                    opti_type   = OPTI_TYPE_ZERO_BYTE
9219                                | OPTI_TYPE_PRECOMPUTE_INIT
9220                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9221                                | OPTI_TYPE_MEET_IN_MIDDLE
9222                                | OPTI_TYPE_EARLY_SKIP
9223                                | OPTI_TYPE_NOT_ITERATED
9224                                | OPTI_TYPE_RAW_HASH;
9225                    dgst_pos0   = 0;
9226                    dgst_pos1   = 3;
9227                    dgst_pos2   = 2;
9228                    dgst_pos3   = 1;
9229                    break;
9230
9231       case  4900:  hash_type   = HASH_TYPE_SHA1;
9232                    salt_type   = SALT_TYPE_INTERN;
9233                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9234                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9235                    kern_type   = KERN_TYPE_SHA1_SLT_PW_SLT;
9236                    dgst_size   = DGST_SIZE_4_5;
9237                    parse_func  = sha1s_parse_hash;
9238                    sort_by_digest = sort_by_digest_4_5;
9239                    opti_type   = OPTI_TYPE_ZERO_BYTE
9240                                | OPTI_TYPE_PRECOMPUTE_INIT
9241                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9242                                | OPTI_TYPE_EARLY_SKIP;
9243                    dgst_pos0   = 3;
9244                    dgst_pos1   = 4;
9245                    dgst_pos2   = 2;
9246                    dgst_pos3   = 1;
9247                    break;
9248
9249       case  5000:  hash_type   = HASH_TYPE_KECCAK;
9250                    salt_type   = SALT_TYPE_EMBEDDED;
9251                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9252                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9253                                | OPTS_TYPE_PT_ADD01;
9254                    kern_type   = KERN_TYPE_KECCAK;
9255                    dgst_size   = DGST_SIZE_8_25;
9256                    parse_func  = keccak_parse_hash;
9257                    sort_by_digest = sort_by_digest_8_25;
9258                    opti_type   = OPTI_TYPE_ZERO_BYTE
9259                                | OPTI_TYPE_USES_BITS_64
9260                                | OPTI_TYPE_RAW_HASH;
9261                    dgst_pos0   = 2;
9262                    dgst_pos1   = 3;
9263                    dgst_pos2   = 4;
9264                    dgst_pos3   = 5;
9265                    break;
9266
9267       case  5100:  hash_type   = HASH_TYPE_MD5H;
9268                    salt_type   = SALT_TYPE_NONE;
9269                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9270                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9271                                | OPTS_TYPE_PT_ADD80
9272                                | OPTS_TYPE_PT_ADDBITS14;
9273                    kern_type   = KERN_TYPE_MD5H;
9274                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9275                    parse_func  = md5half_parse_hash;
9276                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9277                    opti_type   = OPTI_TYPE_ZERO_BYTE
9278                                | OPTI_TYPE_RAW_HASH;
9279                    dgst_pos0   = 0;
9280                    dgst_pos1   = 1;
9281                    dgst_pos2   = 2;
9282                    dgst_pos3   = 3;
9283                    break;
9284
9285       case  5200:  hash_type   = HASH_TYPE_SHA256;
9286                    salt_type   = SALT_TYPE_EMBEDDED;
9287                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9288                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9289                    kern_type   = KERN_TYPE_PSAFE3;
9290                    dgst_size   = DGST_SIZE_4_8;
9291                    parse_func  = psafe3_parse_hash;
9292                    sort_by_digest = sort_by_digest_4_8;
9293                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9294                    dgst_pos0   = 0;
9295                    dgst_pos1   = 1;
9296                    dgst_pos2   = 2;
9297                    dgst_pos3   = 3;
9298                    break;
9299
9300       case  5300:  hash_type   = HASH_TYPE_MD5;
9301                    salt_type   = SALT_TYPE_EMBEDDED;
9302                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9304                                | OPTS_TYPE_ST_ADD80;
9305                    kern_type   = KERN_TYPE_IKEPSK_MD5;
9306                    dgst_size   = DGST_SIZE_4_4;
9307                    parse_func  = ikepsk_md5_parse_hash;
9308                    sort_by_digest = sort_by_digest_4_4;
9309                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9310                    dgst_pos0   = 0;
9311                    dgst_pos1   = 3;
9312                    dgst_pos2   = 2;
9313                    dgst_pos3   = 1;
9314                    break;
9315
9316       case  5400:  hash_type   = HASH_TYPE_SHA1;
9317                    salt_type   = SALT_TYPE_EMBEDDED;
9318                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9319                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9320                                | OPTS_TYPE_ST_ADD80;
9321                    kern_type   = KERN_TYPE_IKEPSK_SHA1;
9322                    dgst_size   = DGST_SIZE_4_5;
9323                    parse_func  = ikepsk_sha1_parse_hash;
9324                    sort_by_digest = sort_by_digest_4_5;
9325                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9326                    dgst_pos0   = 3;
9327                    dgst_pos1   = 4;
9328                    dgst_pos2   = 2;
9329                    dgst_pos3   = 1;
9330                    break;
9331
9332       case  5500:  hash_type   = HASH_TYPE_NETNTLM;
9333                    salt_type   = SALT_TYPE_EMBEDDED;
9334                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9335                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9336                                | OPTS_TYPE_PT_ADD80
9337                                | OPTS_TYPE_PT_ADDBITS14
9338                                | OPTS_TYPE_PT_UNICODE
9339                                | OPTS_TYPE_ST_HEX;
9340                    kern_type   = KERN_TYPE_NETNTLMv1;
9341                    dgst_size   = DGST_SIZE_4_4;
9342                    parse_func  = netntlmv1_parse_hash;
9343                    sort_by_digest = sort_by_digest_4_4;
9344                    opti_type   = OPTI_TYPE_ZERO_BYTE
9345                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9346                    dgst_pos0   = 0;
9347                    dgst_pos1   = 1;
9348                    dgst_pos2   = 2;
9349                    dgst_pos3   = 3;
9350                    break;
9351
9352       case  5600:  hash_type   = HASH_TYPE_MD5;
9353                    salt_type   = SALT_TYPE_EMBEDDED;
9354                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9356                                | OPTS_TYPE_PT_ADD80
9357                                | OPTS_TYPE_PT_ADDBITS14
9358                                | OPTS_TYPE_PT_UNICODE;
9359                    kern_type   = KERN_TYPE_NETNTLMv2;
9360                    dgst_size   = DGST_SIZE_4_4;
9361                    parse_func  = netntlmv2_parse_hash;
9362                    sort_by_digest = sort_by_digest_4_4;
9363                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9364                    dgst_pos0   = 0;
9365                    dgst_pos1   = 3;
9366                    dgst_pos2   = 2;
9367                    dgst_pos3   = 1;
9368                    break;
9369
9370       case  5700:  hash_type   = HASH_TYPE_SHA256;
9371                    salt_type   = SALT_TYPE_NONE;
9372                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9374                                | OPTS_TYPE_PT_ADD80
9375                                | OPTS_TYPE_PT_ADDBITS15;
9376                    kern_type   = KERN_TYPE_SHA256;
9377                    dgst_size   = DGST_SIZE_4_8;
9378                    parse_func  = cisco4_parse_hash;
9379                    sort_by_digest = sort_by_digest_4_8;
9380                    opti_type   = OPTI_TYPE_ZERO_BYTE
9381                                | OPTI_TYPE_PRECOMPUTE_INIT
9382                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9383                                | OPTI_TYPE_EARLY_SKIP
9384                                | OPTI_TYPE_NOT_ITERATED
9385                                | OPTI_TYPE_NOT_SALTED
9386                                | OPTI_TYPE_RAW_HASH;
9387                    dgst_pos0   = 3;
9388                    dgst_pos1   = 7;
9389                    dgst_pos2   = 2;
9390                    dgst_pos3   = 6;
9391                    break;
9392
9393       case  5800:  hash_type   = HASH_TYPE_SHA1;
9394                    salt_type   = SALT_TYPE_INTERN;
9395                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9396                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
9397                                | OPTS_TYPE_ST_ADD80;
9398                    kern_type   = KERN_TYPE_ANDROIDPIN;
9399                    dgst_size   = DGST_SIZE_4_5;
9400                    parse_func  = androidpin_parse_hash;
9401                    sort_by_digest = sort_by_digest_4_5;
9402                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9403                    dgst_pos0   = 0;
9404                    dgst_pos1   = 1;
9405                    dgst_pos2   = 2;
9406                    dgst_pos3   = 3;
9407                    break;
9408
9409       case  6000:  hash_type   = HASH_TYPE_RIPEMD160;
9410                    salt_type   = SALT_TYPE_NONE;
9411                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9413                                | OPTS_TYPE_PT_ADD80;
9414                    kern_type   = KERN_TYPE_RIPEMD160;
9415                    dgst_size   = DGST_SIZE_4_5;
9416                    parse_func  = ripemd160_parse_hash;
9417                    sort_by_digest = sort_by_digest_4_5;
9418                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9419                    dgst_pos0   = 0;
9420                    dgst_pos1   = 1;
9421                    dgst_pos2   = 2;
9422                    dgst_pos3   = 3;
9423                    break;
9424
9425       case  6100:  hash_type   = HASH_TYPE_WHIRLPOOL;
9426                    salt_type   = SALT_TYPE_NONE;
9427                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9428                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9429                                | OPTS_TYPE_PT_ADD80;
9430                    kern_type   = KERN_TYPE_WHIRLPOOL;
9431                    dgst_size   = DGST_SIZE_4_16;
9432                    parse_func  = whirlpool_parse_hash;
9433                    sort_by_digest = sort_by_digest_4_16;
9434                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9435                    dgst_pos0   = 0;
9436                    dgst_pos1   = 1;
9437                    dgst_pos2   = 2;
9438                    dgst_pos3   = 3;
9439                    break;
9440
9441       case  6211:  hash_type   = HASH_TYPE_RIPEMD160;
9442                    salt_type   = SALT_TYPE_EMBEDDED;
9443                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9445                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9446                    dgst_size   = DGST_SIZE_4_5;
9447                    parse_func  = truecrypt_parse_hash_2k;
9448                    sort_by_digest = sort_by_digest_4_5;
9449                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9450                    dgst_pos0   = 0;
9451                    dgst_pos1   = 1;
9452                    dgst_pos2   = 2;
9453                    dgst_pos3   = 3;
9454                    break;
9455
9456       case  6212:  hash_type   = HASH_TYPE_RIPEMD160;
9457                    salt_type   = SALT_TYPE_EMBEDDED;
9458                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9460                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9461                    dgst_size   = DGST_SIZE_4_5;
9462                    parse_func  = truecrypt_parse_hash_2k;
9463                    sort_by_digest = sort_by_digest_4_5;
9464                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9465                    dgst_pos0   = 0;
9466                    dgst_pos1   = 1;
9467                    dgst_pos2   = 2;
9468                    dgst_pos3   = 3;
9469                    break;
9470
9471       case  6213:  hash_type   = HASH_TYPE_RIPEMD160;
9472                    salt_type   = SALT_TYPE_EMBEDDED;
9473                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9475                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9476                    dgst_size   = DGST_SIZE_4_5;
9477                    parse_func  = truecrypt_parse_hash_2k;
9478                    sort_by_digest = sort_by_digest_4_5;
9479                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9480                    dgst_pos0   = 0;
9481                    dgst_pos1   = 1;
9482                    dgst_pos2   = 2;
9483                    dgst_pos3   = 3;
9484                    break;
9485
9486       case  6221:  hash_type   = HASH_TYPE_SHA512;
9487                    salt_type   = SALT_TYPE_EMBEDDED;
9488                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9490                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
9491                    dgst_size   = DGST_SIZE_8_8;
9492                    parse_func  = truecrypt_parse_hash_1k;
9493                    sort_by_digest = sort_by_digest_8_8;
9494                    opti_type   = OPTI_TYPE_ZERO_BYTE
9495                                | OPTI_TYPE_USES_BITS_64;
9496                    dgst_pos0   = 0;
9497                    dgst_pos1   = 1;
9498                    dgst_pos2   = 2;
9499                    dgst_pos3   = 3;
9500                    break;
9501
9502       case  6222:  hash_type   = HASH_TYPE_SHA512;
9503                    salt_type   = SALT_TYPE_EMBEDDED;
9504                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9505                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9506                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
9507                    dgst_size   = DGST_SIZE_8_8;
9508                    parse_func  = truecrypt_parse_hash_1k;
9509                    sort_by_digest = sort_by_digest_8_8;
9510                    opti_type   = OPTI_TYPE_ZERO_BYTE
9511                                | OPTI_TYPE_USES_BITS_64;
9512                    dgst_pos0   = 0;
9513                    dgst_pos1   = 1;
9514                    dgst_pos2   = 2;
9515                    dgst_pos3   = 3;
9516                    break;
9517
9518       case  6223:  hash_type   = HASH_TYPE_SHA512;
9519                    salt_type   = SALT_TYPE_EMBEDDED;
9520                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9522                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
9523                    dgst_size   = DGST_SIZE_8_8;
9524                    parse_func  = truecrypt_parse_hash_1k;
9525                    sort_by_digest = sort_by_digest_8_8;
9526                    opti_type   = OPTI_TYPE_ZERO_BYTE
9527                                | OPTI_TYPE_USES_BITS_64;
9528                    dgst_pos0   = 0;
9529                    dgst_pos1   = 1;
9530                    dgst_pos2   = 2;
9531                    dgst_pos3   = 3;
9532                    break;
9533
9534       case  6231:  hash_type   = HASH_TYPE_WHIRLPOOL;
9535                    salt_type   = SALT_TYPE_EMBEDDED;
9536                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9538                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
9539                    dgst_size   = DGST_SIZE_4_8;
9540                    parse_func  = truecrypt_parse_hash_1k;
9541                    sort_by_digest = sort_by_digest_4_8;
9542                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9543                    dgst_pos0   = 0;
9544                    dgst_pos1   = 1;
9545                    dgst_pos2   = 2;
9546                    dgst_pos3   = 3;
9547                    break;
9548
9549       case  6232:  hash_type   = HASH_TYPE_WHIRLPOOL;
9550                    salt_type   = SALT_TYPE_EMBEDDED;
9551                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9552                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9553                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9554                    dgst_size   = DGST_SIZE_4_8;
9555                    parse_func  = truecrypt_parse_hash_1k;
9556                    sort_by_digest = sort_by_digest_4_8;
9557                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9558                    dgst_pos0   = 0;
9559                    dgst_pos1   = 1;
9560                    dgst_pos2   = 2;
9561                    dgst_pos3   = 3;
9562                    break;
9563
9564       case  6233:  hash_type   = HASH_TYPE_WHIRLPOOL;
9565                    salt_type   = SALT_TYPE_EMBEDDED;
9566                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9567                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9568                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9569                    dgst_size   = DGST_SIZE_4_8;
9570                    parse_func  = truecrypt_parse_hash_1k;
9571                    sort_by_digest = sort_by_digest_4_8;
9572                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9573                    dgst_pos0   = 0;
9574                    dgst_pos1   = 1;
9575                    dgst_pos2   = 2;
9576                    dgst_pos3   = 3;
9577                    break;
9578
9579       case  6241:  hash_type   = HASH_TYPE_RIPEMD160;
9580                    salt_type   = SALT_TYPE_EMBEDDED;
9581                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9582                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9583                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9584                    dgst_size   = DGST_SIZE_4_5;
9585                    parse_func  = truecrypt_parse_hash_1k;
9586                    sort_by_digest = sort_by_digest_4_5;
9587                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9588                    dgst_pos0   = 0;
9589                    dgst_pos1   = 1;
9590                    dgst_pos2   = 2;
9591                    dgst_pos3   = 3;
9592                    break;
9593
9594       case  6242:  hash_type   = HASH_TYPE_RIPEMD160;
9595                    salt_type   = SALT_TYPE_EMBEDDED;
9596                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9597                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9598                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9599                    dgst_size   = DGST_SIZE_4_5;
9600                    parse_func  = truecrypt_parse_hash_1k;
9601                    sort_by_digest = sort_by_digest_4_5;
9602                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9603                    dgst_pos0   = 0;
9604                    dgst_pos1   = 1;
9605                    dgst_pos2   = 2;
9606                    dgst_pos3   = 3;
9607                    break;
9608
9609       case  6243:  hash_type   = HASH_TYPE_RIPEMD160;
9610                    salt_type   = SALT_TYPE_EMBEDDED;
9611                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9612                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9613                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9614                    dgst_size   = DGST_SIZE_4_5;
9615                    parse_func  = truecrypt_parse_hash_1k;
9616                    sort_by_digest = sort_by_digest_4_5;
9617                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9618                    dgst_pos0   = 0;
9619                    dgst_pos1   = 1;
9620                    dgst_pos2   = 2;
9621                    dgst_pos3   = 3;
9622                    break;
9623
9624       case  6300:  hash_type   = HASH_TYPE_MD5;
9625                    salt_type   = SALT_TYPE_EMBEDDED;
9626                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9627                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9628                    kern_type   = KERN_TYPE_MD5AIX;
9629                    dgst_size   = DGST_SIZE_4_4;
9630                    parse_func  = md5aix_parse_hash;
9631                    sort_by_digest = sort_by_digest_4_4;
9632                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9633                    dgst_pos0   = 0;
9634                    dgst_pos1   = 1;
9635                    dgst_pos2   = 2;
9636                    dgst_pos3   = 3;
9637                    break;
9638
9639       case  6400:  hash_type   = HASH_TYPE_SHA256;
9640                    salt_type   = SALT_TYPE_EMBEDDED;
9641                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9643                    kern_type   = KERN_TYPE_SHA256AIX;
9644                    dgst_size   = DGST_SIZE_4_8;
9645                    parse_func  = sha256aix_parse_hash;
9646                    sort_by_digest = sort_by_digest_4_8;
9647                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9648                    dgst_pos0   = 0;
9649                    dgst_pos1   = 1;
9650                    dgst_pos2   = 2;
9651                    dgst_pos3   = 3;
9652                    break;
9653
9654       case  6500:  hash_type   = HASH_TYPE_SHA512;
9655                    salt_type   = SALT_TYPE_EMBEDDED;
9656                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9658                    kern_type   = KERN_TYPE_SHA512AIX;
9659                    dgst_size   = DGST_SIZE_8_8;
9660                    parse_func  = sha512aix_parse_hash;
9661                    sort_by_digest = sort_by_digest_8_8;
9662                    opti_type   = OPTI_TYPE_ZERO_BYTE
9663                                | OPTI_TYPE_USES_BITS_64;
9664                    dgst_pos0   = 0;
9665                    dgst_pos1   = 1;
9666                    dgst_pos2   = 2;
9667                    dgst_pos3   = 3;
9668                    break;
9669
9670       case  6600:  hash_type   = HASH_TYPE_AES;
9671                    salt_type   = SALT_TYPE_EMBEDDED;
9672                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9673                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9674                    kern_type   = KERN_TYPE_AGILEKEY;
9675                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
9676                    parse_func  = agilekey_parse_hash;
9677                    sort_by_digest = sort_by_digest_4_5;
9678                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9679                    dgst_pos0   = 0;
9680                    dgst_pos1   = 1;
9681                    dgst_pos2   = 2;
9682                    dgst_pos3   = 3;
9683                    break;
9684
9685       case  6700:  hash_type   = HASH_TYPE_SHA1;
9686                    salt_type   = SALT_TYPE_EMBEDDED;
9687                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9688                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9689                    kern_type   = KERN_TYPE_SHA1AIX;
9690                    dgst_size   = DGST_SIZE_4_5;
9691                    parse_func  = sha1aix_parse_hash;
9692                    sort_by_digest = sort_by_digest_4_5;
9693                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9694                    dgst_pos0   = 0;
9695                    dgst_pos1   = 1;
9696                    dgst_pos2   = 2;
9697                    dgst_pos3   = 3;
9698                    break;
9699
9700       case  6800:  hash_type   = HASH_TYPE_AES;
9701                    salt_type   = SALT_TYPE_EMBEDDED;
9702                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9703                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9704                    kern_type   = KERN_TYPE_LASTPASS;
9705                    dgst_size   = DGST_SIZE_4_8; // because kernel uses _SHA256_
9706                    parse_func  = lastpass_parse_hash;
9707                    sort_by_digest = sort_by_digest_4_8;
9708                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9709                    dgst_pos0   = 0;
9710                    dgst_pos1   = 1;
9711                    dgst_pos2   = 2;
9712                    dgst_pos3   = 3;
9713                    break;
9714
9715       case  6900:  hash_type   = HASH_TYPE_GOST;
9716                    salt_type   = SALT_TYPE_NONE;
9717                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9719                    kern_type   = KERN_TYPE_GOST;
9720                    dgst_size   = DGST_SIZE_4_8;
9721                    parse_func  = gost_parse_hash;
9722                    sort_by_digest = sort_by_digest_4_8;
9723                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9724                    dgst_pos0   = 0;
9725                    dgst_pos1   = 1;
9726                    dgst_pos2   = 2;
9727                    dgst_pos3   = 3;
9728                    break;
9729
9730       case  7100:  hash_type   = HASH_TYPE_SHA512;
9731                    salt_type   = SALT_TYPE_EMBEDDED;
9732                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9734                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
9735                    dgst_size   = DGST_SIZE_8_16;
9736                    parse_func  = sha512osx_parse_hash;
9737                    sort_by_digest = sort_by_digest_8_16;
9738                    opti_type   = OPTI_TYPE_ZERO_BYTE
9739                                | OPTI_TYPE_USES_BITS_64
9740                                | OPTI_TYPE_SLOW_HASH_SIMD;
9741                    dgst_pos0   = 0;
9742                    dgst_pos1   = 1;
9743                    dgst_pos2   = 2;
9744                    dgst_pos3   = 3;
9745                    break;
9746
9747       case  7200:  hash_type   = HASH_TYPE_SHA512;
9748                    salt_type   = SALT_TYPE_EMBEDDED;
9749                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9750                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9751                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
9752                    dgst_size   = DGST_SIZE_8_16;
9753                    parse_func  = sha512grub_parse_hash;
9754                    sort_by_digest = sort_by_digest_8_16;
9755                    opti_type   = OPTI_TYPE_ZERO_BYTE
9756                                | OPTI_TYPE_USES_BITS_64
9757                                | OPTI_TYPE_SLOW_HASH_SIMD;
9758                    dgst_pos0   = 0;
9759                    dgst_pos1   = 1;
9760                    dgst_pos2   = 2;
9761                    dgst_pos3   = 3;
9762                    break;
9763
9764       case  7300:  hash_type   = HASH_TYPE_SHA1;
9765                    salt_type   = SALT_TYPE_EMBEDDED;
9766                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9767                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9768                                | OPTS_TYPE_ST_ADD80
9769                                | OPTS_TYPE_ST_ADDBITS15;
9770                    kern_type   = KERN_TYPE_RAKP;
9771                    dgst_size   = DGST_SIZE_4_5;
9772                    parse_func  = rakp_parse_hash;
9773                    sort_by_digest = sort_by_digest_4_5;
9774                    opti_type   = OPTI_TYPE_ZERO_BYTE
9775                                | OPTI_TYPE_NOT_ITERATED;
9776                    dgst_pos0   = 3;
9777                    dgst_pos1   = 4;
9778                    dgst_pos2   = 2;
9779                    dgst_pos3   = 1;
9780                    break;
9781
9782       case  7400:  hash_type   = HASH_TYPE_SHA256;
9783                    salt_type   = SALT_TYPE_EMBEDDED;
9784                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9785                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9786                    kern_type   = KERN_TYPE_SHA256CRYPT;
9787                    dgst_size   = DGST_SIZE_4_8;
9788                    parse_func  = sha256crypt_parse_hash;
9789                    sort_by_digest = sort_by_digest_4_8;
9790                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9791                    dgst_pos0   = 0;
9792                    dgst_pos1   = 1;
9793                    dgst_pos2   = 2;
9794                    dgst_pos3   = 3;
9795                    break;
9796
9797       case  7500:  hash_type   = HASH_TYPE_KRB5PA;
9798                    salt_type   = SALT_TYPE_EMBEDDED;
9799                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9801                    kern_type   = KERN_TYPE_KRB5PA;
9802                    dgst_size   = DGST_SIZE_4_4;
9803                    parse_func  = krb5pa_parse_hash;
9804                    sort_by_digest = sort_by_digest_4_4;
9805                    opti_type   = OPTI_TYPE_ZERO_BYTE
9806                                | OPTI_TYPE_NOT_ITERATED;
9807                    dgst_pos0   = 0;
9808                    dgst_pos1   = 1;
9809                    dgst_pos2   = 2;
9810                    dgst_pos3   = 3;
9811                    break;
9812
9813       case  7600:  hash_type   = HASH_TYPE_SHA1;
9814                    salt_type   = SALT_TYPE_INTERN;
9815                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9816                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9817                                | OPTS_TYPE_PT_ADD80
9818                                | OPTS_TYPE_PT_ADDBITS15;
9819                    kern_type   = KERN_TYPE_SHA1_SLT_SHA1_PW;
9820                    dgst_size   = DGST_SIZE_4_5;
9821                    parse_func  = redmine_parse_hash;
9822                    sort_by_digest = sort_by_digest_4_5;
9823                    opti_type   = OPTI_TYPE_ZERO_BYTE
9824                                | OPTI_TYPE_PRECOMPUTE_INIT
9825                                | OPTI_TYPE_EARLY_SKIP
9826                                | OPTI_TYPE_NOT_ITERATED
9827                                | OPTI_TYPE_PREPENDED_SALT;
9828                    dgst_pos0   = 3;
9829                    dgst_pos1   = 4;
9830                    dgst_pos2   = 2;
9831                    dgst_pos3   = 1;
9832                    break;
9833
9834       case  7700:  hash_type   = HASH_TYPE_SAPB;
9835                    salt_type   = SALT_TYPE_EMBEDDED;
9836                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9837                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9838                                | OPTS_TYPE_PT_UPPER
9839                                | OPTS_TYPE_ST_UPPER;
9840                    kern_type   = KERN_TYPE_SAPB;
9841                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9842                    parse_func  = sapb_parse_hash;
9843                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9844                    opti_type   = OPTI_TYPE_ZERO_BYTE
9845                                | OPTI_TYPE_PRECOMPUTE_INIT
9846                                | OPTI_TYPE_NOT_ITERATED;
9847                    dgst_pos0   = 0;
9848                    dgst_pos1   = 1;
9849                    dgst_pos2   = 2;
9850                    dgst_pos3   = 3;
9851                    break;
9852
9853       case  7800:  hash_type   = HASH_TYPE_SAPG;
9854                    salt_type   = SALT_TYPE_EMBEDDED;
9855                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9856                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9857                                | OPTS_TYPE_ST_ADD80
9858                                | OPTS_TYPE_ST_UPPER;
9859                    kern_type   = KERN_TYPE_SAPG;
9860                    dgst_size   = DGST_SIZE_4_5;
9861                    parse_func  = sapg_parse_hash;
9862                    sort_by_digest = sort_by_digest_4_5;
9863                    opti_type   = OPTI_TYPE_ZERO_BYTE
9864                                | OPTI_TYPE_PRECOMPUTE_INIT
9865                                | OPTI_TYPE_NOT_ITERATED;
9866                    dgst_pos0   = 3;
9867                    dgst_pos1   = 4;
9868                    dgst_pos2   = 2;
9869                    dgst_pos3   = 1;
9870                    break;
9871
9872       case  7900:  hash_type   = HASH_TYPE_SHA512;
9873                    salt_type   = SALT_TYPE_EMBEDDED;
9874                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9875                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9876                    kern_type   = KERN_TYPE_DRUPAL7;
9877                    dgst_size   = DGST_SIZE_8_8;
9878                    parse_func  = drupal7_parse_hash;
9879                    sort_by_digest = sort_by_digest_8_8;
9880                    opti_type   = OPTI_TYPE_ZERO_BYTE
9881                                | OPTI_TYPE_USES_BITS_64;
9882                    dgst_pos0   = 0;
9883                    dgst_pos1   = 1;
9884                    dgst_pos2   = 2;
9885                    dgst_pos3   = 3;
9886                    break;
9887
9888       case  8000:  hash_type   = HASH_TYPE_SHA256;
9889                    salt_type   = SALT_TYPE_EMBEDDED;
9890                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9891                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9892                                | OPTS_TYPE_PT_UNICODE
9893                                | OPTS_TYPE_ST_ADD80
9894                                | OPTS_TYPE_ST_HEX;
9895                    kern_type   = KERN_TYPE_SYBASEASE;
9896                    dgst_size   = DGST_SIZE_4_8;
9897                    parse_func  = sybasease_parse_hash;
9898                    sort_by_digest = sort_by_digest_4_8;
9899                    opti_type   = OPTI_TYPE_ZERO_BYTE
9900                                | OPTI_TYPE_PRECOMPUTE_INIT
9901                                | OPTI_TYPE_EARLY_SKIP
9902                                | OPTI_TYPE_NOT_ITERATED
9903                                | OPTI_TYPE_RAW_HASH;
9904                    dgst_pos0   = 3;
9905                    dgst_pos1   = 7;
9906                    dgst_pos2   = 2;
9907                    dgst_pos3   = 6;
9908                    break;
9909
9910       case  8100:  hash_type   = HASH_TYPE_SHA1;
9911                    salt_type   = SALT_TYPE_EMBEDDED;
9912                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9913                    opts_type   = OPTS_TYPE_PT_GENERATE_BE;
9914                    kern_type   = KERN_TYPE_NETSCALER;
9915                    dgst_size   = DGST_SIZE_4_5;
9916                    parse_func  = netscaler_parse_hash;
9917                    sort_by_digest = sort_by_digest_4_5;
9918                    opti_type   = OPTI_TYPE_ZERO_BYTE
9919                                | OPTI_TYPE_PRECOMPUTE_INIT
9920                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9921                                | OPTI_TYPE_EARLY_SKIP
9922                                | OPTI_TYPE_NOT_ITERATED
9923                                | OPTI_TYPE_PREPENDED_SALT
9924                                | OPTI_TYPE_RAW_HASH;
9925                    dgst_pos0   = 3;
9926                    dgst_pos1   = 4;
9927                    dgst_pos2   = 2;
9928                    dgst_pos3   = 1;
9929                    break;
9930
9931       case  8200:  hash_type   = HASH_TYPE_SHA256;
9932                    salt_type   = SALT_TYPE_EMBEDDED;
9933                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9935                    kern_type   = KERN_TYPE_CLOUDKEY;
9936                    dgst_size   = DGST_SIZE_4_8;
9937                    parse_func  = cloudkey_parse_hash;
9938                    sort_by_digest = sort_by_digest_4_8;
9939                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9940                    dgst_pos0   = 0;
9941                    dgst_pos1   = 1;
9942                    dgst_pos2   = 2;
9943                    dgst_pos3   = 3;
9944                    break;
9945
9946       case  8300:  hash_type   = HASH_TYPE_SHA1;
9947                    salt_type   = SALT_TYPE_EMBEDDED;
9948                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9950                                | OPTS_TYPE_ST_HEX
9951                                | OPTS_TYPE_ST_ADD80;
9952                    kern_type   = KERN_TYPE_NSEC3;
9953                    dgst_size   = DGST_SIZE_4_5;
9954                    parse_func  = nsec3_parse_hash;
9955                    sort_by_digest = sort_by_digest_4_5;
9956                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9957                    dgst_pos0   = 3;
9958                    dgst_pos1   = 4;
9959                    dgst_pos2   = 2;
9960                    dgst_pos3   = 1;
9961                    break;
9962
9963       case  8400:  hash_type   = HASH_TYPE_SHA1;
9964                    salt_type   = SALT_TYPE_INTERN;
9965                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9967                                | OPTS_TYPE_PT_ADD80
9968                                | OPTS_TYPE_PT_ADDBITS15;
9969                    kern_type   = KERN_TYPE_WBB3;
9970                    dgst_size   = DGST_SIZE_4_5;
9971                    parse_func  = wbb3_parse_hash;
9972                    sort_by_digest = sort_by_digest_4_5;
9973                    opti_type   = OPTI_TYPE_ZERO_BYTE
9974                                | OPTI_TYPE_PRECOMPUTE_INIT
9975                                | OPTI_TYPE_NOT_ITERATED;
9976                    dgst_pos0   = 3;
9977                    dgst_pos1   = 4;
9978                    dgst_pos2   = 2;
9979                    dgst_pos3   = 1;
9980                    break;
9981
9982       case  8500:  hash_type   = HASH_TYPE_DESRACF;
9983                    salt_type   = SALT_TYPE_EMBEDDED;
9984                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9985                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9986                                | OPTS_TYPE_ST_UPPER;
9987                    kern_type   = KERN_TYPE_RACF;
9988                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9989                    parse_func  = racf_parse_hash;
9990                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9991                    opti_type   = OPTI_TYPE_ZERO_BYTE
9992                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9993                    dgst_pos0   = 0;
9994                    dgst_pos1   = 1;
9995                    dgst_pos2   = 2;
9996                    dgst_pos3   = 3;
9997                    break;
9998
9999       case  8600:  hash_type   = HASH_TYPE_LOTUS5;
10000                    salt_type   = SALT_TYPE_NONE;
10001                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10003                    kern_type   = KERN_TYPE_LOTUS5;
10004                    dgst_size   = DGST_SIZE_4_4;
10005                    parse_func  = lotus5_parse_hash;
10006                    sort_by_digest = sort_by_digest_4_4;
10007                    opti_type   = OPTI_TYPE_EARLY_SKIP
10008                                | OPTI_TYPE_NOT_ITERATED
10009                                | OPTI_TYPE_NOT_SALTED
10010                                | OPTI_TYPE_RAW_HASH;
10011                    dgst_pos0   = 0;
10012                    dgst_pos1   = 1;
10013                    dgst_pos2   = 2;
10014                    dgst_pos3   = 3;
10015                    break;
10016
10017       case  8700:  hash_type   = HASH_TYPE_LOTUS6;
10018                    salt_type   = SALT_TYPE_EMBEDDED;
10019                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10020                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10021                    kern_type   = KERN_TYPE_LOTUS6;
10022                    dgst_size   = DGST_SIZE_4_4;
10023                    parse_func  = lotus6_parse_hash;
10024                    sort_by_digest = sort_by_digest_4_4;
10025                    opti_type   = OPTI_TYPE_EARLY_SKIP
10026                                | OPTI_TYPE_NOT_ITERATED
10027                                | OPTI_TYPE_RAW_HASH;
10028                    dgst_pos0   = 0;
10029                    dgst_pos1   = 1;
10030                    dgst_pos2   = 2;
10031                    dgst_pos3   = 3;
10032                    break;
10033
10034       case  8800:  hash_type   = HASH_TYPE_ANDROIDFDE;
10035                    salt_type   = SALT_TYPE_EMBEDDED;
10036                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10037                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10038                    kern_type   = KERN_TYPE_ANDROIDFDE;
10039                    dgst_size   = DGST_SIZE_4_4;
10040                    parse_func  = androidfde_parse_hash;
10041                    sort_by_digest = sort_by_digest_4_4;
10042                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10043                    dgst_pos0   = 0;
10044                    dgst_pos1   = 1;
10045                    dgst_pos2   = 2;
10046                    dgst_pos3   = 3;
10047                    break;
10048
10049       case  8900:  hash_type   = HASH_TYPE_SCRYPT;
10050                    salt_type   = SALT_TYPE_EMBEDDED;
10051                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10053                    kern_type   = KERN_TYPE_SCRYPT;
10054                    dgst_size   = DGST_SIZE_4_8;
10055                    parse_func  = scrypt_parse_hash;
10056                    sort_by_digest = sort_by_digest_4_8;
10057                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10058                    dgst_pos0   = 0;
10059                    dgst_pos1   = 1;
10060                    dgst_pos2   = 2;
10061                    dgst_pos3   = 3;
10062                    break;
10063
10064       case  9000:  hash_type   = HASH_TYPE_SHA1;
10065                    salt_type   = SALT_TYPE_EMBEDDED;
10066                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10067                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10068                                | OPTS_TYPE_ST_GENERATE_LE;
10069                    kern_type   = KERN_TYPE_PSAFE2;
10070                    dgst_size   = DGST_SIZE_4_5;
10071                    parse_func  = psafe2_parse_hash;
10072                    sort_by_digest = sort_by_digest_4_5;
10073                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10074                    dgst_pos0   = 0;
10075                    dgst_pos1   = 1;
10076                    dgst_pos2   = 2;
10077                    dgst_pos3   = 3;
10078                    break;
10079
10080       case  9100:  hash_type   = HASH_TYPE_LOTUS8;
10081                    salt_type   = SALT_TYPE_EMBEDDED;
10082                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10083                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10084                    kern_type   = KERN_TYPE_LOTUS8;
10085                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10086                    parse_func  = lotus8_parse_hash;
10087                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10088                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10089                    dgst_pos0   = 0;
10090                    dgst_pos1   = 1;
10091                    dgst_pos2   = 2;
10092                    dgst_pos3   = 3;
10093                    break;
10094
10095       case  9200:  hash_type   = HASH_TYPE_SHA256;
10096                    salt_type   = SALT_TYPE_EMBEDDED;
10097                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10099                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10100                    dgst_size   = DGST_SIZE_4_32;
10101                    parse_func  = cisco8_parse_hash;
10102                    sort_by_digest = sort_by_digest_4_32;
10103                    opti_type   = OPTI_TYPE_ZERO_BYTE
10104                                | OPTI_TYPE_SLOW_HASH_SIMD;
10105                    dgst_pos0   = 0;
10106                    dgst_pos1   = 1;
10107                    dgst_pos2   = 2;
10108                    dgst_pos3   = 3;
10109                    break;
10110
10111       case  9300:  hash_type   = HASH_TYPE_SCRYPT;
10112                    salt_type   = SALT_TYPE_EMBEDDED;
10113                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10114                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10115                    kern_type   = KERN_TYPE_SCRYPT;
10116                    dgst_size   = DGST_SIZE_4_8;
10117                    parse_func  = cisco9_parse_hash;
10118                    sort_by_digest = sort_by_digest_4_8;
10119                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10120                    dgst_pos0   = 0;
10121                    dgst_pos1   = 1;
10122                    dgst_pos2   = 2;
10123                    dgst_pos3   = 3;
10124                    break;
10125
10126       case  9400:  hash_type   = HASH_TYPE_OFFICE2007;
10127                    salt_type   = SALT_TYPE_EMBEDDED;
10128                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10129                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10130                    kern_type   = KERN_TYPE_OFFICE2007;
10131                    dgst_size   = DGST_SIZE_4_4;
10132                    parse_func  = office2007_parse_hash;
10133                    sort_by_digest = sort_by_digest_4_4;
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  9500:  hash_type   = HASH_TYPE_OFFICE2010;
10142                    salt_type   = SALT_TYPE_EMBEDDED;
10143                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10145                    kern_type   = KERN_TYPE_OFFICE2010;
10146                    dgst_size   = DGST_SIZE_4_4;
10147                    parse_func  = office2010_parse_hash;
10148                    sort_by_digest = sort_by_digest_4_4;
10149                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10150                    dgst_pos0   = 0;
10151                    dgst_pos1   = 1;
10152                    dgst_pos2   = 2;
10153                    dgst_pos3   = 3;
10154                    break;
10155
10156       case  9600:  hash_type   = HASH_TYPE_OFFICE2013;
10157                    salt_type   = SALT_TYPE_EMBEDDED;
10158                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10159                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10160                    kern_type   = KERN_TYPE_OFFICE2013;
10161                    dgst_size   = DGST_SIZE_4_4;
10162                    parse_func  = office2013_parse_hash;
10163                    sort_by_digest = sort_by_digest_4_4;
10164                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10165                    dgst_pos0   = 0;
10166                    dgst_pos1   = 1;
10167                    dgst_pos2   = 2;
10168                    dgst_pos3   = 3;
10169                    break;
10170
10171       case  9700:  hash_type   = HASH_TYPE_OLDOFFICE01;
10172                    salt_type   = SALT_TYPE_EMBEDDED;
10173                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10174                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10175                                | OPTS_TYPE_PT_ADD80
10176                                | OPTS_TYPE_PT_UNICODE;
10177                    kern_type   = KERN_TYPE_OLDOFFICE01;
10178                    dgst_size   = DGST_SIZE_4_4;
10179                    parse_func  = oldoffice01_parse_hash;
10180                    sort_by_digest = sort_by_digest_4_4;
10181                    opti_type   = OPTI_TYPE_ZERO_BYTE
10182                                | OPTI_TYPE_PRECOMPUTE_INIT
10183                                | OPTI_TYPE_NOT_ITERATED;
10184                    dgst_pos0   = 0;
10185                    dgst_pos1   = 1;
10186                    dgst_pos2   = 2;
10187                    dgst_pos3   = 3;
10188                    break;
10189
10190       case  9710:  hash_type   = HASH_TYPE_OLDOFFICE01;
10191                    salt_type   = SALT_TYPE_EMBEDDED;
10192                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10193                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10194                                | OPTS_TYPE_PT_ADD80;
10195                    kern_type   = KERN_TYPE_OLDOFFICE01CM1;
10196                    dgst_size   = DGST_SIZE_4_4;
10197                    parse_func  = oldoffice01cm1_parse_hash;
10198                    sort_by_digest = sort_by_digest_4_4;
10199                    opti_type   = OPTI_TYPE_ZERO_BYTE
10200                                | OPTI_TYPE_PRECOMPUTE_INIT
10201                                | OPTI_TYPE_NOT_ITERATED;
10202                    dgst_pos0   = 0;
10203                    dgst_pos1   = 1;
10204                    dgst_pos2   = 2;
10205                    dgst_pos3   = 3;
10206                    break;
10207
10208       case  9720:  hash_type   = HASH_TYPE_OLDOFFICE01;
10209                    salt_type   = SALT_TYPE_EMBEDDED;
10210                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10212                                | OPTS_TYPE_PT_ADD80
10213                                | OPTS_TYPE_PT_UNICODE
10214                                | OPTS_TYPE_PT_NEVERCRACK;
10215                    kern_type   = KERN_TYPE_OLDOFFICE01CM2;
10216                    dgst_size   = DGST_SIZE_4_4;
10217                    parse_func  = oldoffice01cm2_parse_hash;
10218                    sort_by_digest = sort_by_digest_4_4;
10219                    opti_type   = OPTI_TYPE_ZERO_BYTE
10220                                | OPTI_TYPE_PRECOMPUTE_INIT
10221                                | OPTI_TYPE_NOT_ITERATED;
10222                    dgst_pos0   = 0;
10223                    dgst_pos1   = 1;
10224                    dgst_pos2   = 2;
10225                    dgst_pos3   = 3;
10226                    break;
10227
10228       case  9800:  hash_type   = HASH_TYPE_OLDOFFICE34;
10229                    salt_type   = SALT_TYPE_EMBEDDED;
10230                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10231                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10232                                | OPTS_TYPE_PT_ADD80
10233                                | OPTS_TYPE_PT_UNICODE;
10234                    kern_type   = KERN_TYPE_OLDOFFICE34;
10235                    dgst_size   = DGST_SIZE_4_4;
10236                    parse_func  = oldoffice34_parse_hash;
10237                    sort_by_digest = sort_by_digest_4_4;
10238                    opti_type   = OPTI_TYPE_ZERO_BYTE
10239                                | OPTI_TYPE_PRECOMPUTE_INIT
10240                                | OPTI_TYPE_NOT_ITERATED;
10241                    dgst_pos0   = 0;
10242                    dgst_pos1   = 1;
10243                    dgst_pos2   = 2;
10244                    dgst_pos3   = 3;
10245                    break;
10246
10247       case  9810:  hash_type   = HASH_TYPE_OLDOFFICE34;
10248                    salt_type   = SALT_TYPE_EMBEDDED;
10249                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10250                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10251                    kern_type   = KERN_TYPE_OLDOFFICE34CM1;
10252                    dgst_size   = DGST_SIZE_4_4;
10253                    parse_func  = oldoffice34cm1_parse_hash;
10254                    sort_by_digest = sort_by_digest_4_4;
10255                    opti_type   = OPTI_TYPE_ZERO_BYTE
10256                                | OPTI_TYPE_PRECOMPUTE_INIT
10257                                | OPTI_TYPE_NOT_ITERATED;
10258                    dgst_pos0   = 0;
10259                    dgst_pos1   = 1;
10260                    dgst_pos2   = 2;
10261                    dgst_pos3   = 3;
10262                    break;
10263
10264       case  9820:  hash_type   = HASH_TYPE_OLDOFFICE34;
10265                    salt_type   = SALT_TYPE_EMBEDDED;
10266                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10267                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10268                                | OPTS_TYPE_PT_ADD80
10269                                | OPTS_TYPE_PT_UNICODE
10270                                | OPTS_TYPE_PT_NEVERCRACK;
10271                    kern_type   = KERN_TYPE_OLDOFFICE34CM2;
10272                    dgst_size   = DGST_SIZE_4_4;
10273                    parse_func  = oldoffice34cm2_parse_hash;
10274                    sort_by_digest = sort_by_digest_4_4;
10275                    opti_type   = OPTI_TYPE_ZERO_BYTE
10276                                | OPTI_TYPE_PRECOMPUTE_INIT
10277                                | OPTI_TYPE_NOT_ITERATED;
10278                    dgst_pos0   = 0;
10279                    dgst_pos1   = 1;
10280                    dgst_pos2   = 2;
10281                    dgst_pos3   = 3;
10282                    break;
10283
10284       case  9900:  hash_type   = HASH_TYPE_MD5;
10285                    salt_type   = SALT_TYPE_NONE;
10286                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10288                    kern_type   = KERN_TYPE_RADMIN2;
10289                    dgst_size   = DGST_SIZE_4_4;
10290                    parse_func  = radmin2_parse_hash;
10291                    sort_by_digest = sort_by_digest_4_4;
10292                    opti_type   = OPTI_TYPE_ZERO_BYTE
10293                                | OPTI_TYPE_PRECOMPUTE_INIT
10294                                | OPTI_TYPE_EARLY_SKIP
10295                                | OPTI_TYPE_NOT_ITERATED
10296                                | OPTI_TYPE_NOT_SALTED;
10297                    dgst_pos0   = 0;
10298                    dgst_pos1   = 3;
10299                    dgst_pos2   = 2;
10300                    dgst_pos3   = 1;
10301                    break;
10302
10303       case 10000:  hash_type   = HASH_TYPE_SHA256;
10304                    salt_type   = SALT_TYPE_EMBEDDED;
10305                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10307                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10308                    dgst_size   = DGST_SIZE_4_32;
10309                    parse_func  = djangopbkdf2_parse_hash;
10310                    sort_by_digest = sort_by_digest_4_32;
10311                    opti_type   = OPTI_TYPE_ZERO_BYTE
10312                                | OPTI_TYPE_SLOW_HASH_SIMD;
10313                    dgst_pos0   = 0;
10314                    dgst_pos1   = 1;
10315                    dgst_pos2   = 2;
10316                    dgst_pos3   = 3;
10317                    break;
10318
10319       case 10100:  hash_type   = HASH_TYPE_SIPHASH;
10320                    salt_type   = SALT_TYPE_EMBEDDED;
10321                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10322                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10323                    kern_type   = KERN_TYPE_SIPHASH;
10324                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10325                    parse_func  = siphash_parse_hash;
10326                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10327                    opti_type   = OPTI_TYPE_ZERO_BYTE
10328                                | OPTI_TYPE_NOT_ITERATED
10329                                | OPTI_TYPE_RAW_HASH;
10330                    dgst_pos0   = 0;
10331                    dgst_pos1   = 1;
10332                    dgst_pos2   = 2;
10333                    dgst_pos3   = 3;
10334                    break;
10335
10336       case 10200:  hash_type   = HASH_TYPE_MD5;
10337                    salt_type   = SALT_TYPE_EMBEDDED;
10338                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10339                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10340                                | OPTS_TYPE_ST_ADD80
10341                                | OPTS_TYPE_ST_ADDBITS14;
10342                    kern_type   = KERN_TYPE_HMACMD5_PW;
10343                    dgst_size   = DGST_SIZE_4_4;
10344                    parse_func  = crammd5_parse_hash;
10345                    sort_by_digest = sort_by_digest_4_4;
10346                    opti_type   = OPTI_TYPE_ZERO_BYTE
10347                                | OPTI_TYPE_NOT_ITERATED;
10348                    dgst_pos0   = 0;
10349                    dgst_pos1   = 3;
10350                    dgst_pos2   = 2;
10351                    dgst_pos3   = 1;
10352                    break;
10353
10354       case 10300:  hash_type   = HASH_TYPE_SHA1;
10355                    salt_type   = SALT_TYPE_EMBEDDED;
10356                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10357                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10358                    kern_type   = KERN_TYPE_SAPH_SHA1;
10359                    dgst_size   = DGST_SIZE_4_5;
10360                    parse_func  = saph_sha1_parse_hash;
10361                    sort_by_digest = sort_by_digest_4_5;
10362                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10363                    dgst_pos0   = 0;
10364                    dgst_pos1   = 1;
10365                    dgst_pos2   = 2;
10366                    dgst_pos3   = 3;
10367                    break;
10368
10369       case 10400:  hash_type   = HASH_TYPE_PDFU16;
10370                    salt_type   = SALT_TYPE_EMBEDDED;
10371                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10372                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10373                    kern_type   = KERN_TYPE_PDF11;
10374                    dgst_size   = DGST_SIZE_4_4;
10375                    parse_func  = pdf11_parse_hash;
10376                    sort_by_digest = sort_by_digest_4_4;
10377                    opti_type   = OPTI_TYPE_ZERO_BYTE
10378                                | OPTI_TYPE_NOT_ITERATED;
10379                    dgst_pos0   = 0;
10380                    dgst_pos1   = 1;
10381                    dgst_pos2   = 2;
10382                    dgst_pos3   = 3;
10383                    break;
10384
10385       case 10410:  hash_type   = HASH_TYPE_PDFU16;
10386                    salt_type   = SALT_TYPE_EMBEDDED;
10387                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10388                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10389                    kern_type   = KERN_TYPE_PDF11CM1;
10390                    dgst_size   = DGST_SIZE_4_4;
10391                    parse_func  = pdf11cm1_parse_hash;
10392                    sort_by_digest = sort_by_digest_4_4;
10393                    opti_type   = OPTI_TYPE_ZERO_BYTE
10394                                | OPTI_TYPE_NOT_ITERATED;
10395                    dgst_pos0   = 0;
10396                    dgst_pos1   = 1;
10397                    dgst_pos2   = 2;
10398                    dgst_pos3   = 3;
10399                    break;
10400
10401       case 10420:  hash_type   = HASH_TYPE_PDFU16;
10402                    salt_type   = SALT_TYPE_EMBEDDED;
10403                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10404                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10405                    kern_type   = KERN_TYPE_PDF11CM2;
10406                    dgst_size   = DGST_SIZE_4_4;
10407                    parse_func  = pdf11cm2_parse_hash;
10408                    sort_by_digest = sort_by_digest_4_4;
10409                    opti_type   = OPTI_TYPE_ZERO_BYTE
10410                                | OPTI_TYPE_NOT_ITERATED;
10411                    dgst_pos0   = 0;
10412                    dgst_pos1   = 1;
10413                    dgst_pos2   = 2;
10414                    dgst_pos3   = 3;
10415                    break;
10416
10417       case 10500:  hash_type   = HASH_TYPE_PDFU16;
10418                    salt_type   = SALT_TYPE_EMBEDDED;
10419                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10420                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10421                    kern_type   = KERN_TYPE_PDF14;
10422                    dgst_size   = DGST_SIZE_4_4;
10423                    parse_func  = pdf14_parse_hash;
10424                    sort_by_digest = sort_by_digest_4_4;
10425                    opti_type   = OPTI_TYPE_ZERO_BYTE
10426                                | OPTI_TYPE_NOT_ITERATED;
10427                    dgst_pos0   = 0;
10428                    dgst_pos1   = 1;
10429                    dgst_pos2   = 2;
10430                    dgst_pos3   = 3;
10431                    break;
10432
10433       case 10600:  hash_type   = HASH_TYPE_SHA256;
10434                    salt_type   = SALT_TYPE_EMBEDDED;
10435                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10436                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10437                                | OPTS_TYPE_ST_ADD80
10438                                | OPTS_TYPE_ST_ADDBITS15
10439                                | OPTS_TYPE_HASH_COPY;
10440                    kern_type   = KERN_TYPE_SHA256_PWSLT;
10441                    dgst_size   = DGST_SIZE_4_8;
10442                    parse_func  = pdf17l3_parse_hash;
10443                    sort_by_digest = sort_by_digest_4_8;
10444                    opti_type   = OPTI_TYPE_ZERO_BYTE
10445                                | OPTI_TYPE_PRECOMPUTE_INIT
10446                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10447                                | OPTI_TYPE_EARLY_SKIP
10448                                | OPTI_TYPE_NOT_ITERATED
10449                                | OPTI_TYPE_APPENDED_SALT
10450                                | OPTI_TYPE_RAW_HASH;
10451                    dgst_pos0   = 3;
10452                    dgst_pos1   = 7;
10453                    dgst_pos2   = 2;
10454                    dgst_pos3   = 6;
10455                    break;
10456
10457       case 10700:  hash_type   = HASH_TYPE_PDFU32;
10458                    salt_type   = SALT_TYPE_EMBEDDED;
10459                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10460                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10461                                | OPTS_TYPE_HASH_COPY;
10462                    kern_type   = KERN_TYPE_PDF17L8;
10463                    dgst_size   = DGST_SIZE_4_8;
10464                    parse_func  = pdf17l8_parse_hash;
10465                    sort_by_digest = sort_by_digest_4_8;
10466                    opti_type   = OPTI_TYPE_ZERO_BYTE
10467                                | OPTI_TYPE_NOT_ITERATED;
10468                    dgst_pos0   = 0;
10469                    dgst_pos1   = 1;
10470                    dgst_pos2   = 2;
10471                    dgst_pos3   = 3;
10472                    break;
10473
10474       case 10800:  hash_type   = HASH_TYPE_SHA384;
10475                    salt_type   = SALT_TYPE_NONE;
10476                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10477                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10478                                | OPTS_TYPE_PT_ADD80
10479                                | OPTS_TYPE_PT_ADDBITS15;
10480                    kern_type   = KERN_TYPE_SHA384;
10481                    dgst_size   = DGST_SIZE_8_8;
10482                    parse_func  = sha384_parse_hash;
10483                    sort_by_digest = sort_by_digest_8_8;
10484                    opti_type   = OPTI_TYPE_ZERO_BYTE
10485                                | OPTI_TYPE_PRECOMPUTE_INIT
10486                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10487                                | OPTI_TYPE_EARLY_SKIP
10488                                | OPTI_TYPE_NOT_ITERATED
10489                                | OPTI_TYPE_NOT_SALTED
10490                                | OPTI_TYPE_USES_BITS_64
10491                                | OPTI_TYPE_RAW_HASH;
10492                    dgst_pos0   = 6;
10493                    dgst_pos1   = 7;
10494                    dgst_pos2   = 4;
10495                    dgst_pos3   = 5;
10496                    break;
10497
10498       case 10900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10499                    salt_type   = SALT_TYPE_EMBEDDED;
10500                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10501                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10502                                | OPTS_TYPE_ST_BASE64
10503                                | OPTS_TYPE_HASH_COPY;
10504                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10505                    dgst_size   = DGST_SIZE_4_32;
10506                    parse_func  = pbkdf2_sha256_parse_hash;
10507                    sort_by_digest = sort_by_digest_4_32;
10508                    opti_type   = OPTI_TYPE_ZERO_BYTE
10509                                | OPTI_TYPE_SLOW_HASH_SIMD;
10510                    dgst_pos0   = 0;
10511                    dgst_pos1   = 1;
10512                    dgst_pos2   = 2;
10513                    dgst_pos3   = 3;
10514                    break;
10515
10516       case 11000:  hash_type   = HASH_TYPE_MD5;
10517                    salt_type   = SALT_TYPE_INTERN;
10518                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10519                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10520                                | OPTS_TYPE_PT_ADD80;
10521                    kern_type   = KERN_TYPE_PRESTASHOP;
10522                    dgst_size   = DGST_SIZE_4_4;
10523                    parse_func  = prestashop_parse_hash;
10524                    sort_by_digest = sort_by_digest_4_4;
10525                    opti_type   = OPTI_TYPE_ZERO_BYTE
10526                                | OPTI_TYPE_PRECOMPUTE_INIT
10527                                | OPTI_TYPE_NOT_ITERATED
10528                                | OPTI_TYPE_PREPENDED_SALT;
10529                    dgst_pos0   = 0;
10530                    dgst_pos1   = 3;
10531                    dgst_pos2   = 2;
10532                    dgst_pos3   = 1;
10533                    break;
10534
10535       case 11100:  hash_type   = HASH_TYPE_MD5;
10536                    salt_type   = SALT_TYPE_EMBEDDED;
10537                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10538                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10539                                | OPTS_TYPE_ST_ADD80;
10540                    kern_type   = KERN_TYPE_POSTGRESQL_AUTH;
10541                    dgst_size   = DGST_SIZE_4_4;
10542                    parse_func  = postgresql_auth_parse_hash;
10543                    sort_by_digest = sort_by_digest_4_4;
10544                    opti_type   = OPTI_TYPE_ZERO_BYTE
10545                                | OPTI_TYPE_PRECOMPUTE_INIT
10546                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10547                                | OPTI_TYPE_EARLY_SKIP;
10548                    dgst_pos0   = 0;
10549                    dgst_pos1   = 3;
10550                    dgst_pos2   = 2;
10551                    dgst_pos3   = 1;
10552                    break;
10553
10554       case 11200:  hash_type   = HASH_TYPE_SHA1;
10555                    salt_type   = SALT_TYPE_EMBEDDED;
10556                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10557                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10558                                | OPTS_TYPE_PT_ADD80
10559                                | OPTS_TYPE_ST_HEX;
10560                    kern_type   = KERN_TYPE_MYSQL_AUTH;
10561                    dgst_size   = DGST_SIZE_4_5;
10562                    parse_func  = mysql_auth_parse_hash;
10563                    sort_by_digest = sort_by_digest_4_5;
10564                    opti_type   = OPTI_TYPE_ZERO_BYTE
10565                                | OPTI_TYPE_EARLY_SKIP;
10566                    dgst_pos0   = 3;
10567                    dgst_pos1   = 4;
10568                    dgst_pos2   = 2;
10569                    dgst_pos3   = 1;
10570                    break;
10571
10572       case 11300:  hash_type   = HASH_TYPE_BITCOIN_WALLET;
10573                    salt_type   = SALT_TYPE_EMBEDDED;
10574                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10575                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10576                                | OPTS_TYPE_ST_HEX
10577                                | OPTS_TYPE_ST_ADD80;
10578                    kern_type   = KERN_TYPE_BITCOIN_WALLET;
10579                    dgst_size   = DGST_SIZE_4_4;
10580                    parse_func  = bitcoin_wallet_parse_hash;
10581                    sort_by_digest = sort_by_digest_4_4;
10582                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10583                    dgst_pos0   = 0;
10584                    dgst_pos1   = 1;
10585                    dgst_pos2   = 2;
10586                    dgst_pos3   = 3;
10587                    break;
10588
10589       case 11400:  hash_type   = HASH_TYPE_MD5;
10590                    salt_type   = SALT_TYPE_EMBEDDED;
10591                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10592                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10593                                | OPTS_TYPE_PT_ADD80
10594                                | OPTS_TYPE_HASH_COPY;
10595                    kern_type   = KERN_TYPE_SIP_AUTH;
10596                    dgst_size   = DGST_SIZE_4_4;
10597                    parse_func  = sip_auth_parse_hash;
10598                    sort_by_digest = sort_by_digest_4_4;
10599                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10600                    dgst_pos0   = 0;
10601                    dgst_pos1   = 3;
10602                    dgst_pos2   = 2;
10603                    dgst_pos3   = 1;
10604                    break;
10605
10606       case 11500:  hash_type   = HASH_TYPE_CRC32;
10607                    salt_type   = SALT_TYPE_INTERN;
10608                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10609                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10610                                | OPTS_TYPE_ST_GENERATE_LE
10611                                | OPTS_TYPE_ST_HEX;
10612                    kern_type   = KERN_TYPE_CRC32;
10613                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10614                    parse_func  = crc32_parse_hash;
10615                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10616                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10617                    dgst_pos0   = 0;
10618                    dgst_pos1   = 1;
10619                    dgst_pos2   = 2;
10620                    dgst_pos3   = 3;
10621                    break;
10622
10623       case 11600:  hash_type   = HASH_TYPE_AES;
10624                    salt_type   = SALT_TYPE_EMBEDDED;
10625                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10627                                | OPTS_TYPE_PT_NEVERCRACK;
10628                    kern_type   = KERN_TYPE_SEVEN_ZIP;
10629                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10630                    parse_func  = seven_zip_parse_hash;
10631                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10632                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10633                    dgst_pos0   = 0;
10634                    dgst_pos1   = 1;
10635                    dgst_pos2   = 2;
10636                    dgst_pos3   = 3;
10637                    break;
10638
10639       case 11700:  hash_type   = HASH_TYPE_GOST_2012SBOG_256;
10640                    salt_type   = SALT_TYPE_NONE;
10641                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10642                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10643                                | OPTS_TYPE_PT_ADD01;
10644                    kern_type   = KERN_TYPE_GOST_2012SBOG_256;
10645                    dgst_size   = DGST_SIZE_4_8;
10646                    parse_func  = gost2012sbog_256_parse_hash;
10647                    sort_by_digest = sort_by_digest_4_8;
10648                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10649                    dgst_pos0   = 0;
10650                    dgst_pos1   = 1;
10651                    dgst_pos2   = 2;
10652                    dgst_pos3   = 3;
10653                    break;
10654
10655       case 11800:  hash_type   = HASH_TYPE_GOST_2012SBOG_512;
10656                    salt_type   = SALT_TYPE_NONE;
10657                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10658                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10659                                | OPTS_TYPE_PT_ADD01;
10660                    kern_type   = KERN_TYPE_GOST_2012SBOG_512;
10661                    dgst_size   = DGST_SIZE_4_16;
10662                    parse_func  = gost2012sbog_512_parse_hash;
10663                    sort_by_digest = sort_by_digest_4_16;
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 11900:  hash_type   = HASH_TYPE_PBKDF2_MD5;
10672                    salt_type   = SALT_TYPE_EMBEDDED;
10673                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10674                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10675                                | OPTS_TYPE_ST_BASE64
10676                                | OPTS_TYPE_HASH_COPY;
10677                    kern_type   = KERN_TYPE_PBKDF2_MD5;
10678                    dgst_size   = DGST_SIZE_4_32;
10679                    parse_func  = pbkdf2_md5_parse_hash;
10680                    sort_by_digest = sort_by_digest_4_32;
10681                    opti_type   = OPTI_TYPE_ZERO_BYTE
10682                                | OPTI_TYPE_SLOW_HASH_SIMD;
10683                    dgst_pos0   = 0;
10684                    dgst_pos1   = 1;
10685                    dgst_pos2   = 2;
10686                    dgst_pos3   = 3;
10687                    break;
10688
10689       case 12000:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
10690                    salt_type   = SALT_TYPE_EMBEDDED;
10691                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10692                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10693                                | OPTS_TYPE_ST_BASE64
10694                                | OPTS_TYPE_HASH_COPY;
10695                    kern_type   = KERN_TYPE_PBKDF2_SHA1;
10696                    dgst_size   = DGST_SIZE_4_32;
10697                    parse_func  = pbkdf2_sha1_parse_hash;
10698                    sort_by_digest = sort_by_digest_4_32;
10699                    opti_type   = OPTI_TYPE_ZERO_BYTE
10700                                | OPTI_TYPE_SLOW_HASH_SIMD;
10701                    dgst_pos0   = 0;
10702                    dgst_pos1   = 1;
10703                    dgst_pos2   = 2;
10704                    dgst_pos3   = 3;
10705                    break;
10706
10707       case 12100:  hash_type   = HASH_TYPE_PBKDF2_SHA512;
10708                    salt_type   = SALT_TYPE_EMBEDDED;
10709                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10710                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10711                                | OPTS_TYPE_ST_BASE64
10712                                | OPTS_TYPE_HASH_COPY;
10713                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
10714                    dgst_size   = DGST_SIZE_8_16;
10715                    parse_func  = pbkdf2_sha512_parse_hash;
10716                    sort_by_digest = sort_by_digest_8_16;
10717                    opti_type   = OPTI_TYPE_ZERO_BYTE
10718                                | OPTI_TYPE_USES_BITS_64
10719                                | OPTI_TYPE_SLOW_HASH_SIMD;
10720                    dgst_pos0   = 0;
10721                    dgst_pos1   = 1;
10722                    dgst_pos2   = 2;
10723                    dgst_pos3   = 3;
10724                    break;
10725
10726       case 12200:  hash_type   = HASH_TYPE_ECRYPTFS;
10727                    salt_type   = SALT_TYPE_EMBEDDED;
10728                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10730                    kern_type   = KERN_TYPE_ECRYPTFS;
10731                    dgst_size   = DGST_SIZE_8_8;
10732                    parse_func  = ecryptfs_parse_hash;
10733                    sort_by_digest = sort_by_digest_8_8;
10734                    opti_type   = OPTI_TYPE_ZERO_BYTE
10735                                | OPTI_TYPE_USES_BITS_64;
10736                    dgst_pos0   = 0;
10737                    dgst_pos1   = 1;
10738                    dgst_pos2   = 2;
10739                    dgst_pos3   = 3;
10740                    break;
10741
10742       case 12300:  hash_type   = HASH_TYPE_ORACLET;
10743                    salt_type   = SALT_TYPE_EMBEDDED;
10744                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10746                    kern_type   = KERN_TYPE_ORACLET;
10747                    dgst_size   = DGST_SIZE_8_16;
10748                    parse_func  = oraclet_parse_hash;
10749                    sort_by_digest = sort_by_digest_8_16;
10750                    opti_type   = OPTI_TYPE_ZERO_BYTE
10751                                | OPTI_TYPE_USES_BITS_64;
10752                    dgst_pos0   = 0;
10753                    dgst_pos1   = 1;
10754                    dgst_pos2   = 2;
10755                    dgst_pos3   = 3;
10756                    break;
10757
10758       case 12400:  hash_type   = HASH_TYPE_BSDICRYPT;
10759                    salt_type   = SALT_TYPE_EMBEDDED;
10760                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10761                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10762                    kern_type   = KERN_TYPE_BSDICRYPT;
10763                    dgst_size   = DGST_SIZE_4_4;
10764                    parse_func  = bsdicrypt_parse_hash;
10765                    sort_by_digest = sort_by_digest_4_4;
10766                    opti_type   = OPTI_TYPE_ZERO_BYTE
10767                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
10768                    dgst_pos0   = 0;
10769                    dgst_pos1   = 1;
10770                    dgst_pos2   = 2;
10771                    dgst_pos3   = 3;
10772                    break;
10773
10774       case 12500:  hash_type   = HASH_TYPE_RAR3HP;
10775                    salt_type   = SALT_TYPE_EMBEDDED;
10776                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10778                    kern_type   = KERN_TYPE_RAR3;
10779                    dgst_size   = DGST_SIZE_4_4;
10780                    parse_func  = rar3hp_parse_hash;
10781                    sort_by_digest = sort_by_digest_4_4;
10782                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10783                    dgst_pos0   = 0;
10784                    dgst_pos1   = 1;
10785                    dgst_pos2   = 2;
10786                    dgst_pos3   = 3;
10787                    break;
10788
10789       case 12600:  hash_type   = HASH_TYPE_SHA256;
10790                    salt_type   = SALT_TYPE_INTERN;
10791                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10792                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10793                                | OPTS_TYPE_PT_ADD80;
10794                    kern_type   = KERN_TYPE_CF10;
10795                    dgst_size   = DGST_SIZE_4_8;
10796                    parse_func  = cf10_parse_hash;
10797                    sort_by_digest = sort_by_digest_4_8;
10798                    opti_type   = OPTI_TYPE_ZERO_BYTE
10799                                | OPTI_TYPE_PRECOMPUTE_INIT
10800                                | OPTI_TYPE_EARLY_SKIP
10801                                | OPTI_TYPE_NOT_ITERATED;
10802                    dgst_pos0   = 3;
10803                    dgst_pos1   = 7;
10804                    dgst_pos2   = 2;
10805                    dgst_pos3   = 6;
10806                    break;
10807
10808       case 12700:  hash_type   = HASH_TYPE_AES;
10809                    salt_type   = SALT_TYPE_EMBEDDED;
10810                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10811                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10812                                | OPTS_TYPE_HASH_COPY;
10813                    kern_type   = KERN_TYPE_MYWALLET;
10814                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
10815                    parse_func  = mywallet_parse_hash;
10816                    sort_by_digest = sort_by_digest_4_5;
10817                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10818                    dgst_pos0   = 0;
10819                    dgst_pos1   = 1;
10820                    dgst_pos2   = 2;
10821                    dgst_pos3   = 3;
10822                    break;
10823
10824       case 12800:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10825                    salt_type   = SALT_TYPE_EMBEDDED;
10826                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10827                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10828                    kern_type   = KERN_TYPE_MS_DRSR;
10829                    dgst_size   = DGST_SIZE_4_8;
10830                    parse_func  = ms_drsr_parse_hash;
10831                    sort_by_digest = sort_by_digest_4_8;
10832                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10833                    dgst_pos0   = 0;
10834                    dgst_pos1   = 1;
10835                    dgst_pos2   = 2;
10836                    dgst_pos3   = 3;
10837                    break;
10838
10839       case 12900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10840                    salt_type   = SALT_TYPE_EMBEDDED;
10841                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10842                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10843                    kern_type   = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10844                    dgst_size   = DGST_SIZE_4_8;
10845                    parse_func  = androidfde_samsung_parse_hash;
10846                    sort_by_digest = sort_by_digest_4_8;
10847                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10848                    dgst_pos0   = 0;
10849                    dgst_pos1   = 1;
10850                    dgst_pos2   = 2;
10851                    dgst_pos3   = 3;
10852                    break;
10853
10854       case 13000:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10855                    salt_type   = SALT_TYPE_EMBEDDED;
10856                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10857                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10858                    kern_type   = KERN_TYPE_RAR5;
10859                    dgst_size   = DGST_SIZE_4_4;
10860                    parse_func  = rar5_parse_hash;
10861                    sort_by_digest = sort_by_digest_4_4;
10862                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10863                    dgst_pos0   = 0;
10864                    dgst_pos1   = 1;
10865                    dgst_pos2   = 2;
10866                    dgst_pos3   = 3;
10867                    break;
10868
10869       case 13100:  hash_type   = HASH_TYPE_KRB5TGS;
10870                    salt_type   = SALT_TYPE_EMBEDDED;
10871                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10872                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10873                    kern_type   = KERN_TYPE_KRB5TGS;
10874                    dgst_size   = DGST_SIZE_4_4;
10875                    parse_func  = krb5tgs_parse_hash;
10876                    sort_by_digest = sort_by_digest_4_4;
10877                    opti_type   = OPTI_TYPE_ZERO_BYTE
10878                                | OPTI_TYPE_NOT_ITERATED;
10879                    dgst_pos0   = 0;
10880                    dgst_pos1   = 1;
10881                    dgst_pos2   = 2;
10882                    dgst_pos3   = 3;
10883                    break;
10884
10885       case 13200:  hash_type   = HASH_TYPE_AES;
10886                    salt_type   = SALT_TYPE_EMBEDDED;
10887                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10888                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10889                    kern_type   = KERN_TYPE_AXCRYPT;
10890                    dgst_size   = DGST_SIZE_4_4;
10891                    parse_func  = axcrypt_parse_hash;
10892                    sort_by_digest = sort_by_digest_4_4;
10893                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10894                    dgst_pos0   = 0;
10895                    dgst_pos1   = 1;
10896                    dgst_pos2   = 2;
10897                    dgst_pos3   = 3;
10898                    break;
10899
10900       case 13300:  hash_type   = HASH_TYPE_SHA1;
10901                    salt_type   = SALT_TYPE_NONE;
10902                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10903                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10904                                | OPTS_TYPE_PT_ADD80
10905                                | OPTS_TYPE_PT_ADDBITS15;
10906                    kern_type   = KERN_TYPE_SHA1_AXCRYPT;
10907                    dgst_size   = DGST_SIZE_4_5;
10908                    parse_func  = sha1axcrypt_parse_hash;
10909                    sort_by_digest = sort_by_digest_4_5;
10910                    opti_type   = OPTI_TYPE_ZERO_BYTE
10911                                | OPTI_TYPE_PRECOMPUTE_INIT
10912                                | OPTI_TYPE_EARLY_SKIP
10913                                | OPTI_TYPE_NOT_ITERATED
10914                                | OPTI_TYPE_NOT_SALTED;
10915                    dgst_pos0   = 0;
10916                    dgst_pos1   = 4;
10917                    dgst_pos2   = 3;
10918                    dgst_pos3   = 2;
10919                    break;
10920
10921       case 13400:  hash_type   = HASH_TYPE_AES;
10922                    salt_type   = SALT_TYPE_EMBEDDED;
10923                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10924                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10925                    kern_type   = KERN_TYPE_KEEPASS;
10926                    dgst_size   = DGST_SIZE_4_4;
10927                    parse_func  = keepass_parse_hash;
10928                    sort_by_digest = sort_by_digest_4_4;
10929                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10930                    dgst_pos0   = 0;
10931                    dgst_pos1   = 1;
10932                    dgst_pos2   = 2;
10933                    dgst_pos3   = 3;
10934                    break;
10935
10936       case 13500:  hash_type   = HASH_TYPE_SHA1;
10937                    salt_type   = SALT_TYPE_EMBEDDED;
10938                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10939                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10940                                | OPTS_TYPE_PT_UNICODE
10941                                | OPTS_TYPE_PT_ADD80;
10942                    kern_type   = KERN_TYPE_PSTOKEN;
10943                    dgst_size   = DGST_SIZE_4_5;
10944                    parse_func  = pstoken_parse_hash;
10945                    sort_by_digest = sort_by_digest_4_5;
10946                    opti_type   = OPTI_TYPE_ZERO_BYTE
10947                                | OPTI_TYPE_PRECOMPUTE_INIT
10948                                | OPTI_TYPE_EARLY_SKIP
10949                                | OPTI_TYPE_NOT_ITERATED
10950                                | OPTI_TYPE_PREPENDED_SALT
10951                                | OPTI_TYPE_RAW_HASH;
10952                    dgst_pos0   = 3;
10953                    dgst_pos1   = 4;
10954                    dgst_pos2   = 2;
10955                    dgst_pos3   = 1;
10956                    break;
10957
10958       case 13600:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
10959                    salt_type   = SALT_TYPE_EMBEDDED;
10960                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10961                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10962                    kern_type   = KERN_TYPE_ZIP2;
10963                    dgst_size   = DGST_SIZE_4_4;
10964                    parse_func  = zip2_parse_hash;
10965                    sort_by_digest = sort_by_digest_4_4;
10966                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10967                    dgst_pos0   = 0;
10968                    dgst_pos1   = 1;
10969                    dgst_pos2   = 2;
10970                    dgst_pos3   = 3;
10971                    break;
10972
10973       case 13711:  hash_type   = HASH_TYPE_RIPEMD160;
10974                    salt_type   = SALT_TYPE_EMBEDDED;
10975                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10976                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10977                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
10978                    dgst_size   = DGST_SIZE_4_5;
10979                    parse_func  = veracrypt_parse_hash_655331;
10980                    sort_by_digest = sort_by_digest_4_5;
10981                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10982                    dgst_pos0   = 0;
10983                    dgst_pos1   = 1;
10984                    dgst_pos2   = 2;
10985                    dgst_pos3   = 3;
10986                    break;
10987
10988       case 13712:  hash_type   = HASH_TYPE_RIPEMD160;
10989                    salt_type   = SALT_TYPE_EMBEDDED;
10990                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10991                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10992                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
10993                    dgst_size   = DGST_SIZE_4_5;
10994                    parse_func  = veracrypt_parse_hash_655331;
10995                    sort_by_digest = sort_by_digest_4_5;
10996                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10997                    dgst_pos0   = 0;
10998                    dgst_pos1   = 1;
10999                    dgst_pos2   = 2;
11000                    dgst_pos3   = 3;
11001                    break;
11002
11003       case 13713:  hash_type   = HASH_TYPE_RIPEMD160;
11004                    salt_type   = SALT_TYPE_EMBEDDED;
11005                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11006                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11007                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
11008                    dgst_size   = DGST_SIZE_4_5;
11009                    parse_func  = veracrypt_parse_hash_655331;
11010                    sort_by_digest = sort_by_digest_4_5;
11011                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11012                    dgst_pos0   = 0;
11013                    dgst_pos1   = 1;
11014                    dgst_pos2   = 2;
11015                    dgst_pos3   = 3;
11016                    break;
11017
11018       case 13721:  hash_type   = HASH_TYPE_SHA512;
11019                    salt_type   = SALT_TYPE_EMBEDDED;
11020                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11021                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11022                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
11023                    dgst_size   = DGST_SIZE_8_8;
11024                    parse_func  = veracrypt_parse_hash_500000;
11025                    sort_by_digest = sort_by_digest_8_8;
11026                    opti_type   = OPTI_TYPE_ZERO_BYTE
11027                                | OPTI_TYPE_USES_BITS_64;
11028                    dgst_pos0   = 0;
11029                    dgst_pos1   = 1;
11030                    dgst_pos2   = 2;
11031                    dgst_pos3   = 3;
11032                    break;
11033
11034       case 13722:  hash_type   = HASH_TYPE_SHA512;
11035                    salt_type   = SALT_TYPE_EMBEDDED;
11036                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11037                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11038                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
11039                    dgst_size   = DGST_SIZE_8_8;
11040                    parse_func  = veracrypt_parse_hash_500000;
11041                    sort_by_digest = sort_by_digest_8_8;
11042                    opti_type   = OPTI_TYPE_ZERO_BYTE
11043                                | OPTI_TYPE_USES_BITS_64;
11044                    dgst_pos0   = 0;
11045                    dgst_pos1   = 1;
11046                    dgst_pos2   = 2;
11047                    dgst_pos3   = 3;
11048                    break;
11049
11050       case 13723:  hash_type   = HASH_TYPE_SHA512;
11051                    salt_type   = SALT_TYPE_EMBEDDED;
11052                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11053                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11054                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
11055                    dgst_size   = DGST_SIZE_8_8;
11056                    parse_func  = veracrypt_parse_hash_500000;
11057                    sort_by_digest = sort_by_digest_8_8;
11058                    opti_type   = OPTI_TYPE_ZERO_BYTE
11059                                | OPTI_TYPE_USES_BITS_64;
11060                    dgst_pos0   = 0;
11061                    dgst_pos1   = 1;
11062                    dgst_pos2   = 2;
11063                    dgst_pos3   = 3;
11064                    break;
11065
11066       case 13731:  hash_type   = HASH_TYPE_WHIRLPOOL;
11067                    salt_type   = SALT_TYPE_EMBEDDED;
11068                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11069                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11070                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
11071                    dgst_size   = DGST_SIZE_4_8;
11072                    parse_func  = veracrypt_parse_hash_500000;
11073                    sort_by_digest = sort_by_digest_4_8;
11074                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11075                    dgst_pos0   = 0;
11076                    dgst_pos1   = 1;
11077                    dgst_pos2   = 2;
11078                    dgst_pos3   = 3;
11079                    break;
11080
11081       case 13732:  hash_type   = HASH_TYPE_WHIRLPOOL;
11082                    salt_type   = SALT_TYPE_EMBEDDED;
11083                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11084                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11085                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11086                    dgst_size   = DGST_SIZE_4_8;
11087                    parse_func  = veracrypt_parse_hash_500000;
11088                    sort_by_digest = sort_by_digest_4_8;
11089                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11090                    dgst_pos0   = 0;
11091                    dgst_pos1   = 1;
11092                    dgst_pos2   = 2;
11093                    dgst_pos3   = 3;
11094                    break;
11095
11096       case 13733:  hash_type   = HASH_TYPE_WHIRLPOOL;
11097                    salt_type   = SALT_TYPE_EMBEDDED;
11098                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11099                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11100                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11101                    dgst_size   = DGST_SIZE_4_8;
11102                    parse_func  = veracrypt_parse_hash_500000;
11103                    sort_by_digest = sort_by_digest_4_8;
11104                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11105                    dgst_pos0   = 0;
11106                    dgst_pos1   = 1;
11107                    dgst_pos2   = 2;
11108                    dgst_pos3   = 3;
11109                    break;
11110
11111       case 13741:  hash_type   = HASH_TYPE_RIPEMD160;
11112                    salt_type   = SALT_TYPE_EMBEDDED;
11113                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11114                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11115                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
11116                    dgst_size   = DGST_SIZE_4_5;
11117                    parse_func  = veracrypt_parse_hash_327661;
11118                    sort_by_digest = sort_by_digest_4_5;
11119                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11120                    dgst_pos0   = 0;
11121                    dgst_pos1   = 1;
11122                    dgst_pos2   = 2;
11123                    dgst_pos3   = 3;
11124                    break;
11125
11126       case 13742:  hash_type   = HASH_TYPE_RIPEMD160;
11127                    salt_type   = SALT_TYPE_EMBEDDED;
11128                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11129                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11130                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
11131                    dgst_size   = DGST_SIZE_4_5;
11132                    parse_func  = veracrypt_parse_hash_327661;
11133                    sort_by_digest = sort_by_digest_4_5;
11134                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11135                    dgst_pos0   = 0;
11136                    dgst_pos1   = 1;
11137                    dgst_pos2   = 2;
11138                    dgst_pos3   = 3;
11139                    break;
11140
11141       case 13743:  hash_type   = HASH_TYPE_RIPEMD160;
11142                    salt_type   = SALT_TYPE_EMBEDDED;
11143                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11144                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11145                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
11146                    dgst_size   = DGST_SIZE_4_5;
11147                    parse_func  = veracrypt_parse_hash_327661;
11148                    sort_by_digest = sort_by_digest_4_5;
11149                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11150                    dgst_pos0   = 0;
11151                    dgst_pos1   = 1;
11152                    dgst_pos2   = 2;
11153                    dgst_pos3   = 3;
11154                    break;
11155
11156       case 13751:  hash_type   = HASH_TYPE_SHA256;
11157                    salt_type   = SALT_TYPE_EMBEDDED;
11158                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11159                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11160                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11161                    dgst_size   = DGST_SIZE_4_8;
11162                    parse_func  = veracrypt_parse_hash_500000;
11163                    sort_by_digest = sort_by_digest_4_8;
11164                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11165                    dgst_pos0   = 0;
11166                    dgst_pos1   = 1;
11167                    dgst_pos2   = 2;
11168                    dgst_pos3   = 3;
11169                    break;
11170
11171       case 13752:  hash_type   = HASH_TYPE_SHA256;
11172                    salt_type   = SALT_TYPE_EMBEDDED;
11173                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11174                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11175                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11176                    dgst_size   = DGST_SIZE_4_8;
11177                    parse_func  = veracrypt_parse_hash_500000;
11178                    sort_by_digest = sort_by_digest_4_8;
11179                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11180                    dgst_pos0   = 0;
11181                    dgst_pos1   = 1;
11182                    dgst_pos2   = 2;
11183                    dgst_pos3   = 3;
11184                    break;
11185
11186       case 13753:  hash_type   = HASH_TYPE_SHA256;
11187                    salt_type   = SALT_TYPE_EMBEDDED;
11188                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11189                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11190                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11191                    dgst_size   = DGST_SIZE_4_8;
11192                    parse_func  = veracrypt_parse_hash_500000;
11193                    sort_by_digest = sort_by_digest_4_8;
11194                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11195                    dgst_pos0   = 0;
11196                    dgst_pos1   = 1;
11197                    dgst_pos2   = 2;
11198                    dgst_pos3   = 3;
11199                    break;
11200
11201       case 13761:  hash_type   = HASH_TYPE_SHA256;
11202                    salt_type   = SALT_TYPE_EMBEDDED;
11203                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11204                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11205                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11206                    dgst_size   = DGST_SIZE_4_8;
11207                    parse_func  = veracrypt_parse_hash_200000;
11208                    sort_by_digest = sort_by_digest_4_8;
11209                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11210                    dgst_pos0   = 0;
11211                    dgst_pos1   = 1;
11212                    dgst_pos2   = 2;
11213                    dgst_pos3   = 3;
11214                    break;
11215
11216       case 13762:  hash_type   = HASH_TYPE_SHA256;
11217                    salt_type   = SALT_TYPE_EMBEDDED;
11218                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11219                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11220                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11221                    dgst_size   = DGST_SIZE_4_8;
11222                    parse_func  = veracrypt_parse_hash_200000;
11223                    sort_by_digest = sort_by_digest_4_8;
11224                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11225                    dgst_pos0   = 0;
11226                    dgst_pos1   = 1;
11227                    dgst_pos2   = 2;
11228                    dgst_pos3   = 3;
11229                    break;
11230
11231       case 13763:  hash_type   = HASH_TYPE_SHA256;
11232                    salt_type   = SALT_TYPE_EMBEDDED;
11233                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11234                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11235                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11236                    dgst_size   = DGST_SIZE_4_8;
11237                    parse_func  = veracrypt_parse_hash_200000;
11238                    sort_by_digest = sort_by_digest_4_8;
11239                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11240                    dgst_pos0   = 0;
11241                    dgst_pos1   = 1;
11242                    dgst_pos2   = 2;
11243                    dgst_pos3   = 3;
11244                    break;
11245
11246       case 13800:  hash_type   = HASH_TYPE_SHA256;
11247                    salt_type   = SALT_TYPE_EMBEDDED;
11248                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11249                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11250                                | OPTS_TYPE_PT_UNICODE;
11251                    kern_type   = KERN_TYPE_WIN8PHONE;
11252                    dgst_size   = DGST_SIZE_4_8;
11253                    parse_func  = win8phone_parse_hash;
11254                    sort_by_digest = sort_by_digest_4_8;
11255                    opti_type   = OPTI_TYPE_ZERO_BYTE
11256                                | OPTI_TYPE_PRECOMPUTE_INIT
11257                                | OPTI_TYPE_EARLY_SKIP
11258                                | OPTI_TYPE_NOT_ITERATED
11259                                | OPTI_TYPE_RAW_HASH;
11260                    dgst_pos0   = 3;
11261                    dgst_pos1   = 7;
11262                    dgst_pos2   = 2;
11263                    dgst_pos3   = 6;
11264                    break;
11265
11266       default:     usage_mini_print (PROGNAME); return (-1);
11267     }
11268
11269     /**
11270      * parser
11271      */
11272
11273     data.parse_func = parse_func;
11274
11275     /**
11276      * misc stuff
11277      */
11278
11279     if (hex_salt)
11280     {
11281       if (salt_type == SALT_TYPE_INTERN)
11282       {
11283         opts_type |= OPTS_TYPE_ST_HEX;
11284       }
11285       else
11286       {
11287         log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11288
11289         return (-1);
11290       }
11291     }
11292
11293     uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11294                   |  (salt_type == SALT_TYPE_EXTERN)
11295                   |  (salt_type == SALT_TYPE_EMBEDDED)
11296                   |  (salt_type == SALT_TYPE_VIRTUAL));
11297
11298     sort_by_digest = sort_by_digest_p0p1;  // overruled by 64 bit digest
11299
11300     data.hash_type   = hash_type;
11301     data.attack_mode = attack_mode;
11302     data.attack_kern = attack_kern;
11303     data.attack_exec = attack_exec;
11304     data.kern_type   = kern_type;
11305     data.opts_type   = opts_type;
11306     data.dgst_size   = dgst_size;
11307     data.salt_type   = salt_type;
11308     data.isSalted    = isSalted;
11309     data.sort_by_digest = sort_by_digest;
11310     data.dgst_pos0   = dgst_pos0;
11311     data.dgst_pos1   = dgst_pos1;
11312     data.dgst_pos2   = dgst_pos2;
11313     data.dgst_pos3   = dgst_pos3;
11314
11315     esalt_size = 0;
11316
11317     switch (hash_mode)
11318     {
11319       case  2500:  esalt_size = sizeof (wpa_t);           break;
11320       case  5300:  esalt_size = sizeof (ikepsk_t);        break;
11321       case  5400:  esalt_size = sizeof (ikepsk_t);        break;
11322       case  5500:  esalt_size = sizeof (netntlm_t);       break;
11323       case  5600:  esalt_size = sizeof (netntlm_t);       break;
11324       case  6211:  esalt_size = sizeof (tc_t);            break;
11325       case  6212:  esalt_size = sizeof (tc_t);            break;
11326       case  6213:  esalt_size = sizeof (tc_t);            break;
11327       case  6221:  esalt_size = sizeof (tc_t);            break;
11328       case  6222:  esalt_size = sizeof (tc_t);            break;
11329       case  6223:  esalt_size = sizeof (tc_t);            break;
11330       case  6231:  esalt_size = sizeof (tc_t);            break;
11331       case  6232:  esalt_size = sizeof (tc_t);            break;
11332       case  6233:  esalt_size = sizeof (tc_t);            break;
11333       case  6241:  esalt_size = sizeof (tc_t);            break;
11334       case  6242:  esalt_size = sizeof (tc_t);            break;
11335       case  6243:  esalt_size = sizeof (tc_t);            break;
11336       case  6600:  esalt_size = sizeof (agilekey_t);      break;
11337       case  7100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11338       case  7200:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11339       case  7300:  esalt_size = sizeof (rakp_t);          break;
11340       case  7500:  esalt_size = sizeof (krb5pa_t);        break;
11341       case  8200:  esalt_size = sizeof (cloudkey_t);      break;
11342       case  8800:  esalt_size = sizeof (androidfde_t);    break;
11343       case  9200:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11344       case  9400:  esalt_size = sizeof (office2007_t);    break;
11345       case  9500:  esalt_size = sizeof (office2010_t);    break;
11346       case  9600:  esalt_size = sizeof (office2013_t);    break;
11347       case  9700:  esalt_size = sizeof (oldoffice01_t);   break;
11348       case  9710:  esalt_size = sizeof (oldoffice01_t);   break;
11349       case  9720:  esalt_size = sizeof (oldoffice01_t);   break;
11350       case  9800:  esalt_size = sizeof (oldoffice34_t);   break;
11351       case  9810:  esalt_size = sizeof (oldoffice34_t);   break;
11352       case  9820:  esalt_size = sizeof (oldoffice34_t);   break;
11353       case 10000:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11354       case 10200:  esalt_size = sizeof (cram_md5_t);      break;
11355       case 10400:  esalt_size = sizeof (pdf_t);           break;
11356       case 10410:  esalt_size = sizeof (pdf_t);           break;
11357       case 10420:  esalt_size = sizeof (pdf_t);           break;
11358       case 10500:  esalt_size = sizeof (pdf_t);           break;
11359       case 10600:  esalt_size = sizeof (pdf_t);           break;
11360       case 10700:  esalt_size = sizeof (pdf_t);           break;
11361       case 10900:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11362       case 11300:  esalt_size = sizeof (bitcoin_wallet_t); break;
11363       case 11400:  esalt_size = sizeof (sip_t);           break;
11364       case 11600:  esalt_size = sizeof (seven_zip_t);     break;
11365       case 11900:  esalt_size = sizeof (pbkdf2_md5_t);    break;
11366       case 12000:  esalt_size = sizeof (pbkdf2_sha1_t);   break;
11367       case 12100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11368       case 13000:  esalt_size = sizeof (rar5_t);          break;
11369       case 13100:  esalt_size = sizeof (krb5tgs_t);       break;
11370       case 13400:  esalt_size = sizeof (keepass_t);       break;
11371       case 13500:  esalt_size = sizeof (pstoken_t);       break;
11372       case 13600:  esalt_size = sizeof (zip2_t);          break;
11373       case 13711:  esalt_size = sizeof (tc_t);            break;
11374       case 13712:  esalt_size = sizeof (tc_t);            break;
11375       case 13713:  esalt_size = sizeof (tc_t);            break;
11376       case 13721:  esalt_size = sizeof (tc_t);            break;
11377       case 13722:  esalt_size = sizeof (tc_t);            break;
11378       case 13723:  esalt_size = sizeof (tc_t);            break;
11379       case 13731:  esalt_size = sizeof (tc_t);            break;
11380       case 13732:  esalt_size = sizeof (tc_t);            break;
11381       case 13733:  esalt_size = sizeof (tc_t);            break;
11382       case 13741:  esalt_size = sizeof (tc_t);            break;
11383       case 13742:  esalt_size = sizeof (tc_t);            break;
11384       case 13743:  esalt_size = sizeof (tc_t);            break;
11385       case 13751:  esalt_size = sizeof (tc_t);            break;
11386       case 13752:  esalt_size = sizeof (tc_t);            break;
11387       case 13753:  esalt_size = sizeof (tc_t);            break;
11388       case 13761:  esalt_size = sizeof (tc_t);            break;
11389       case 13762:  esalt_size = sizeof (tc_t);            break;
11390       case 13763:  esalt_size = sizeof (tc_t);            break;
11391       case 13800:  esalt_size = sizeof (win8phone_t);     break;
11392     }
11393
11394     data.esalt_size = esalt_size;
11395
11396     /**
11397      * choose dictionary parser
11398      */
11399
11400     if (hash_type == HASH_TYPE_LM)
11401     {
11402       get_next_word_func = get_next_word_lm;
11403     }
11404     else if (opts_type & OPTS_TYPE_PT_UPPER)
11405     {
11406       get_next_word_func = get_next_word_uc;
11407     }
11408     else
11409     {
11410       get_next_word_func = get_next_word_std;
11411     }
11412
11413     /**
11414      * dictstat
11415      */
11416
11417     dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11418
11419     #ifdef _POSIX
11420     size_t dictstat_nmemb = 0;
11421     #endif
11422
11423     #ifdef _WIN
11424     uint   dictstat_nmemb = 0;
11425     #endif
11426
11427     char dictstat[256] = { 0 };
11428
11429     FILE *dictstat_fp = NULL;
11430
11431     if (keyspace == 0)
11432     {
11433       snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11434
11435       dictstat_fp = fopen (dictstat, "rb");
11436
11437       if (dictstat_fp)
11438       {
11439         #ifdef _POSIX
11440         struct stat tmpstat;
11441
11442         fstat (fileno (dictstat_fp), &tmpstat);
11443         #endif
11444
11445         #ifdef _WIN
11446         struct stat64 tmpstat;
11447
11448         _fstat64 (fileno (dictstat_fp), &tmpstat);
11449         #endif
11450
11451         if (tmpstat.st_mtime < COMPTIME)
11452         {
11453           /* with v0.15 the format changed so we have to ensure user is using a good version
11454              since there is no version-header in the dictstat file */
11455
11456           fclose (dictstat_fp);
11457
11458           unlink (dictstat);
11459         }
11460         else
11461         {
11462           while (!feof (dictstat_fp))
11463           {
11464             dictstat_t d;
11465
11466             if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11467
11468             lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11469
11470             if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11471             {
11472               log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11473
11474               return -1;
11475             }
11476           }
11477
11478           fclose (dictstat_fp);
11479         }
11480       }
11481     }
11482
11483     /**
11484      * potfile
11485      */
11486
11487     char potfile[256] = { 0 };
11488
11489     if (potfile_path == NULL)
11490     {
11491       snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11492     }
11493     else
11494     {
11495       strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11496     }
11497
11498     data.pot_fp = NULL;
11499
11500     FILE *out_fp = NULL;
11501     FILE *pot_fp = NULL;
11502
11503     if (show == 1 || left == 1)
11504     {
11505       pot_fp = fopen (potfile, "rb");
11506
11507       if (pot_fp == NULL)
11508       {
11509         log_error ("ERROR: %s: %s", potfile, strerror (errno));
11510
11511         return (-1);
11512       }
11513
11514       if (outfile != NULL)
11515       {
11516         if ((out_fp = fopen (outfile, "ab")) == NULL)
11517         {
11518           log_error ("ERROR: %s: %s", outfile, strerror (errno));
11519
11520           fclose (pot_fp);
11521
11522           return (-1);
11523         }
11524       }
11525       else
11526       {
11527         out_fp = stdout;
11528       }
11529     }
11530     else
11531     {
11532       if (potfile_disable == 0)
11533       {
11534         pot_fp = fopen (potfile, "ab");
11535
11536         if (pot_fp == NULL)
11537         {
11538           log_error ("ERROR: %s: %s", potfile, strerror (errno));
11539
11540           return (-1);
11541         }
11542
11543         data.pot_fp = pot_fp;
11544       }
11545     }
11546
11547     pot_t *pot = NULL;
11548
11549     uint pot_cnt   = 0;
11550     uint pot_avail = 0;
11551
11552     if (show == 1 || left == 1)
11553     {
11554       SUPPRESS_OUTPUT = 1;
11555
11556       pot_avail = count_lines (pot_fp);
11557
11558       rewind (pot_fp);
11559
11560       pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11561
11562       uint pot_hashes_avail = 0;
11563
11564       uint line_num = 0;
11565
11566       char *line_buf = (char *) mymalloc (HCBUFSIZ);
11567
11568       while (!feof (pot_fp))
11569       {
11570         line_num++;
11571
11572         int line_len = fgetl (pot_fp, line_buf);
11573
11574         if (line_len == 0) continue;
11575
11576         char *plain_buf = line_buf + line_len;
11577
11578         pot_t *pot_ptr = &pot[pot_cnt];
11579
11580         hash_t *hashes_buf = &pot_ptr->hash;
11581
11582         // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11583         // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11584
11585         if (pot_cnt == pot_hashes_avail)
11586         {
11587           uint pos = 0;
11588
11589           for (pos = 0; pos < INCR_POT; pos++)
11590           {
11591             if ((pot_cnt + pos) >= pot_avail) break;
11592
11593             pot_t *tmp_pot = &pot[pot_cnt + pos];
11594
11595             hash_t *tmp_hash = &tmp_pot->hash;
11596
11597             tmp_hash->digest = mymalloc (dgst_size);
11598
11599             if (isSalted)
11600             {
11601               tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11602             }
11603
11604             if (esalt_size)
11605             {
11606               tmp_hash->esalt = mymalloc (esalt_size);
11607             }
11608
11609             pot_hashes_avail++;
11610           }
11611         }
11612
11613         int plain_len = 0;
11614
11615         int parser_status;
11616
11617         int iter = MAX_CUT_TRIES;
11618
11619         do
11620         {
11621           for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11622           {
11623             if (line_buf[i] == ':')
11624             {
11625               line_len--;
11626
11627               break;
11628             }
11629           }
11630
11631           if (data.hash_mode != 2500)
11632           {
11633             parser_status = parse_func (line_buf, line_len, hashes_buf);
11634           }
11635           else
11636           {
11637             int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11638
11639             if (line_len > max_salt_size)
11640             {
11641               parser_status = PARSER_GLOBAL_LENGTH;
11642             }
11643             else
11644             {
11645               memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11646
11647               memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11648
11649               hashes_buf->salt->salt_len = line_len;
11650
11651               parser_status = PARSER_OK;
11652             }
11653           }
11654
11655           // if NOT parsed without error, we add the ":" to the plain
11656
11657           if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11658           {
11659             plain_len++;
11660             plain_buf--;
11661           }
11662
11663         } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11664
11665         if (parser_status < PARSER_GLOBAL_ZERO)
11666         {
11667           // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11668
11669           continue;
11670         }
11671
11672         if (plain_len >= 255) continue;
11673
11674         memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11675
11676         pot_ptr->plain_len = plain_len;
11677
11678         pot_cnt++;
11679       }
11680
11681       myfree (line_buf);
11682
11683       fclose (pot_fp);
11684
11685       SUPPRESS_OUTPUT = 0;
11686
11687       qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11688     }
11689
11690     /**
11691      * word len
11692      */
11693
11694     uint pw_min = PW_MIN;
11695     uint pw_max = PW_MAX;
11696
11697     switch (hash_mode)
11698     {
11699       case   125: if (pw_max > 32) pw_max = 32;
11700                   break;
11701       case   400: if (pw_max > 40) pw_max = 40;
11702                   break;
11703       case   500: if (pw_max > 16) pw_max = 16;
11704                   break;
11705       case  1500: if (pw_max >  8) pw_max =  8;
11706                   break;
11707       case  1600: if (pw_max > 16) pw_max = 16;
11708                   break;
11709       case  1800: if (pw_max > 16) pw_max = 16;
11710                   break;
11711       case  2100: if (pw_max > 16) pw_max = 16;
11712                   break;
11713       case  2500: if (pw_min <  8) pw_min =  8;
11714                   break;
11715       case  3000: if (pw_max >  7) pw_max =  7;
11716                   break;
11717       case  5200: if (pw_max > 24) pw_max = 24;
11718                   break;
11719       case  5800: if (pw_max > 16) pw_max = 16;
11720                   break;
11721       case  6300: if (pw_max > 16) pw_max = 16;
11722                   break;
11723       case  7400: if (pw_max > 16) pw_max = 16;
11724                   break;
11725       case  7700: if (pw_max >  8) pw_max =  8;
11726                   break;
11727       case  7900: if (pw_max > 48) pw_max = 48;
11728                   break;
11729       case  8500: if (pw_max >  8) pw_max =  8;
11730                   break;
11731       case  8600: if (pw_max > 16) pw_max = 16;
11732                   break;
11733       case  9710: pw_min = 5;
11734                   pw_max = 5;
11735                   break;
11736       case  9810: pw_min = 5;
11737                   pw_max = 5;
11738                   break;
11739       case 10410: pw_min = 5;
11740                   pw_max = 5;
11741                   break;
11742       case 10300: if (pw_max <  3) pw_min =  3;
11743                   if (pw_max > 40) pw_max = 40;
11744                   break;
11745       case 10500: if (pw_max <  3) pw_min =  3;
11746                   if (pw_max > 40) pw_max = 40;
11747                   break;
11748       case 10700: if (pw_max > 16) pw_max = 16;
11749                   break;
11750       case 11300: if (pw_max > 40) pw_max = 40;
11751                   break;
11752       case 11600: if (pw_max > 32) pw_max = 32;
11753                   break;
11754       case 12500: if (pw_max > 20) pw_max = 20;
11755                   break;
11756       case 12800: if (pw_max > 24) pw_max = 24;
11757                   break;
11758     }
11759
11760     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11761     {
11762       switch (attack_kern)
11763       {
11764         case ATTACK_KERN_STRAIGHT:  if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11765                                     break;
11766         case ATTACK_KERN_COMBI:     if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11767                                     break;
11768       }
11769     }
11770
11771     /**
11772      * charsets : keep them together for more easy maintainnce
11773      */
11774
11775     cs_t mp_sys[6] = { { { 0 }, 0 } };
11776     cs_t mp_usr[4] = { { { 0 }, 0 } };
11777
11778     mp_setup_sys (mp_sys);
11779
11780     if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11781     if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11782     if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11783     if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11784
11785     /**
11786      * load hashes, part I: find input mode, count hashes
11787      */
11788
11789     uint hashlist_mode   = 0;
11790     uint hashlist_format = HLFMT_HASHCAT;
11791
11792     uint hashes_avail = 0;
11793
11794     if ((benchmark == 0) && (stdout_flag == 0))
11795     {
11796       struct stat f;
11797
11798       hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11799
11800       if ((hash_mode == 2500) ||
11801           (hash_mode == 5200) ||
11802           ((hash_mode >=  6200) && (hash_mode <=  6299)) ||
11803           ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11804           (hash_mode == 9000))
11805       {
11806         hashlist_mode = HL_MODE_ARG;
11807
11808         char *hashfile = myargv[optind];
11809
11810         data.hashfile = hashfile;
11811
11812         logfile_top_var_string ("target", hashfile);
11813       }
11814
11815       if (hashlist_mode == HL_MODE_ARG)
11816       {
11817         if (hash_mode == 2500)
11818         {
11819           struct stat st;
11820
11821           if (stat (data.hashfile, &st) == -1)
11822           {
11823             log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11824
11825             return (-1);
11826           }
11827
11828           hashes_avail = st.st_size / sizeof (hccap_t);
11829         }
11830         else
11831         {
11832           hashes_avail = 1;
11833         }
11834       }
11835       else if (hashlist_mode == HL_MODE_FILE)
11836       {
11837         char *hashfile = myargv[optind];
11838
11839         data.hashfile = hashfile;
11840
11841         logfile_top_var_string ("target", hashfile);
11842
11843         FILE *fp = NULL;
11844
11845         if ((fp = fopen (hashfile, "rb")) == NULL)
11846         {
11847           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11848
11849           return (-1);
11850         }
11851
11852         if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11853
11854         hashes_avail = count_lines (fp);
11855
11856         rewind (fp);
11857
11858         if (hashes_avail == 0)
11859         {
11860           log_error ("ERROR: hashfile is empty or corrupt");
11861
11862           fclose (fp);
11863
11864           return (-1);
11865         }
11866
11867         hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11868
11869         if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11870         {
11871           log_error ("ERROR: remove not supported in native hashfile-format mode");
11872
11873           fclose (fp);
11874
11875           return (-1);
11876         }
11877
11878         fclose (fp);
11879       }
11880     }
11881     else
11882     {
11883       hashlist_mode = HL_MODE_ARG;
11884
11885       hashes_avail = 1;
11886     }
11887
11888     if (hash_mode == 3000) hashes_avail *= 2;
11889
11890     data.hashlist_mode   = hashlist_mode;
11891     data.hashlist_format = hashlist_format;
11892
11893     logfile_top_uint (hashlist_mode);
11894     logfile_top_uint (hashlist_format);
11895
11896     /**
11897      * load hashes, part II: allocate required memory, set pointers
11898      */
11899
11900     hash_t *hashes_buf  = NULL;
11901     void   *digests_buf = NULL;
11902     salt_t *salts_buf   = NULL;
11903     void   *esalts_buf  = NULL;
11904
11905     hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11906
11907     digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11908
11909     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11910     {
11911       u32 hash_pos;
11912
11913       for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11914       {
11915         hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11916
11917         hashes_buf[hash_pos].hash_info = hash_info;
11918
11919         if (username && (remove || show || left))
11920         {
11921           hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11922         }
11923
11924         if (benchmark)
11925         {
11926           hash_info->orighash = (char *) mymalloc (256);
11927         }
11928       }
11929     }
11930
11931     if (isSalted)
11932     {
11933       salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11934
11935       if (esalt_size)
11936       {
11937         esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11938       }
11939     }
11940     else
11941     {
11942       salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11943     }
11944
11945     for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11946     {
11947       hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11948
11949       if (isSalted)
11950       {
11951         hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11952
11953         if (esalt_size)
11954         {
11955           hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11956         }
11957       }
11958       else
11959       {
11960         hashes_buf[hash_pos].salt = &salts_buf[0];
11961       }
11962     }
11963
11964     /**
11965      * load hashes, part III: parse hashes or generate them if benchmark
11966      */
11967
11968     uint hashes_cnt = 0;
11969
11970     if (benchmark == 0)
11971     {
11972       if (keyspace == 1)
11973       {
11974         // useless to read hash file for keyspace, cheat a little bit w/ optind
11975       }
11976       else if (stdout_flag == 1)
11977       {
11978         // useless to read hash file for stdout, cheat a little bit w/ optind
11979       }
11980       else if (hashes_avail == 0)
11981       {
11982       }
11983       else if (hashlist_mode == HL_MODE_ARG)
11984       {
11985         char *input_buf = myargv[optind];
11986
11987         uint input_len = strlen (input_buf);
11988
11989         logfile_top_var_string ("target", input_buf);
11990
11991         char *hash_buf = NULL;
11992         int   hash_len = 0;
11993
11994         hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11995
11996         bool hash_fmt_error = 0;
11997
11998         if (hash_len < 1)     hash_fmt_error = 1;
11999         if (hash_buf == NULL) hash_fmt_error = 1;
12000
12001         if (hash_fmt_error)
12002         {
12003           log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12004         }
12005         else
12006         {
12007           if (opts_type & OPTS_TYPE_HASH_COPY)
12008           {
12009             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12010
12011             hash_info_tmp->orighash = mystrdup (hash_buf);
12012           }
12013
12014           if (isSalted)
12015           {
12016             memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12017           }
12018
12019           int parser_status = PARSER_OK;
12020
12021           if (hash_mode == 2500)
12022           {
12023             if (hash_len == 0)
12024             {
12025               log_error ("ERROR: hccap file not specified");
12026
12027               return (-1);
12028             }
12029
12030             hashlist_mode = HL_MODE_FILE;
12031
12032             data.hashlist_mode = hashlist_mode;
12033
12034             FILE *fp = fopen (hash_buf, "rb");
12035
12036             if (fp == NULL)
12037             {
12038               log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12039
12040               return (-1);
12041             }
12042
12043             if (hashes_avail < 1)
12044             {
12045               log_error ("ERROR: hccap file is empty or corrupt");
12046
12047               fclose (fp);
12048
12049               return (-1);
12050             }
12051
12052             uint hccap_size = sizeof (hccap_t);
12053
12054             char *in = (char *) mymalloc (hccap_size);
12055
12056             while (!feof (fp))
12057             {
12058               int n = fread (in, hccap_size, 1, fp);
12059
12060               if (n != 1)
12061               {
12062                 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12063
12064                 break;
12065               }
12066
12067               parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12068
12069               if (parser_status != PARSER_OK)
12070               {
12071                 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12072
12073                 continue;
12074               }
12075
12076               // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12077
12078               if ((show == 1) || (left == 1))
12079               {
12080                 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12081
12082                 char *salt_ptr = (char *) tmp_salt->salt_buf;
12083
12084                 int cur_pos = tmp_salt->salt_len;
12085                 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12086
12087                 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12088
12089                 // do the appending task
12090
12091                 snprintf (salt_ptr + cur_pos,
12092                           rem_len,
12093                           ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12094                           wpa->orig_mac1[0],
12095                           wpa->orig_mac1[1],
12096                           wpa->orig_mac1[2],
12097                           wpa->orig_mac1[3],
12098                           wpa->orig_mac1[4],
12099                           wpa->orig_mac1[5],
12100                           wpa->orig_mac2[0],
12101                           wpa->orig_mac2[1],
12102                           wpa->orig_mac2[2],
12103                           wpa->orig_mac2[3],
12104                           wpa->orig_mac2[4],
12105                           wpa->orig_mac2[5]);
12106
12107                 // memset () the remaining part of the salt
12108
12109                 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12110                 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12111
12112                 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12113
12114                 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12115               }
12116
12117               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);
12118               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);
12119
12120               hashes_cnt++;
12121             }
12122
12123             fclose (fp);
12124
12125             myfree (in);
12126           }
12127           else if (hash_mode == 3000)
12128           {
12129             if (hash_len == 32)
12130             {
12131               parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12132
12133               hash_t *lm_hash_left = NULL;
12134
12135               if (parser_status == PARSER_OK)
12136               {
12137                 lm_hash_left = &hashes_buf[hashes_cnt];
12138
12139                 hashes_cnt++;
12140               }
12141               else
12142               {
12143                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12144               }
12145
12146               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12147
12148               hash_t *lm_hash_right = NULL;
12149
12150               if (parser_status == PARSER_OK)
12151               {
12152                 lm_hash_right = &hashes_buf[hashes_cnt];
12153
12154                 hashes_cnt++;
12155               }
12156               else
12157               {
12158                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12159               }
12160
12161               // show / left
12162
12163               if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12164               {
12165                 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);
12166                 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);
12167               }
12168             }
12169             else
12170             {
12171               parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12172
12173               if (parser_status == PARSER_OK)
12174               {
12175                 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12176                 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12177               }
12178
12179               if (parser_status == PARSER_OK)
12180               {
12181                 hashes_cnt++;
12182               }
12183               else
12184               {
12185                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12186               }
12187             }
12188           }
12189           else
12190           {
12191             parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12192
12193             if (parser_status == PARSER_OK)
12194             {
12195               if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12196               if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12197             }
12198
12199             if (parser_status == PARSER_OK)
12200             {
12201               hashes_cnt++;
12202             }
12203             else
12204             {
12205               log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12206             }
12207           }
12208         }
12209       }
12210       else if (hashlist_mode == HL_MODE_FILE)
12211       {
12212         char *hashfile = data.hashfile;
12213
12214         FILE *fp;
12215
12216         if ((fp = fopen (hashfile, "rb")) == NULL)
12217         {
12218           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12219
12220           return (-1);
12221         }
12222
12223         uint line_num = 0;
12224
12225         char *line_buf = (char *) mymalloc (HCBUFSIZ);
12226
12227         while (!feof (fp))
12228         {
12229           line_num++;
12230
12231           int line_len = fgetl (fp, line_buf);
12232
12233           if (line_len == 0) continue;
12234
12235           char *hash_buf = NULL;
12236           int   hash_len = 0;
12237
12238           hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12239
12240           bool hash_fmt_error = 0;
12241
12242           if (hash_len < 1)     hash_fmt_error = 1;
12243           if (hash_buf == NULL) hash_fmt_error = 1;
12244
12245           if (hash_fmt_error)
12246           {
12247             log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12248
12249             continue;
12250           }
12251
12252           if (username)
12253           {
12254             char *user_buf = NULL;
12255             int   user_len = 0;
12256
12257             hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12258
12259             if (remove || show)
12260             {
12261               user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12262
12263               *user = (user_t *) mymalloc (sizeof (user_t));
12264
12265               user_t *user_ptr = *user;
12266
12267               if (user_buf != NULL)
12268               {
12269                 user_ptr->user_name = mystrdup (user_buf);
12270               }
12271               else
12272               {
12273                 user_ptr->user_name = mystrdup ("");
12274               }
12275
12276               user_ptr->user_len = user_len;
12277             }
12278           }
12279
12280           if (opts_type & OPTS_TYPE_HASH_COPY)
12281           {
12282             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12283
12284             hash_info_tmp->orighash = mystrdup (hash_buf);
12285           }
12286
12287           if (isSalted)
12288           {
12289             memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12290           }
12291
12292           if (hash_mode == 3000)
12293           {
12294             if (hash_len == 32)
12295             {
12296               int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12297
12298               if (parser_status < PARSER_GLOBAL_ZERO)
12299               {
12300                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12301
12302                 continue;
12303               }
12304
12305               hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12306
12307               hashes_cnt++;
12308
12309               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12310
12311               if (parser_status < PARSER_GLOBAL_ZERO)
12312               {
12313                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12314
12315                 continue;
12316               }
12317
12318               hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12319
12320               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);
12321
12322               hashes_cnt++;
12323
12324               // show / left
12325
12326               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);
12327               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);
12328             }
12329             else
12330             {
12331               int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12332
12333               if (parser_status < PARSER_GLOBAL_ZERO)
12334               {
12335                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12336
12337                 continue;
12338               }
12339
12340               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);
12341
12342               if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12343               if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12344
12345               hashes_cnt++;
12346             }
12347           }
12348           else
12349           {
12350             int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12351
12352             if (parser_status < PARSER_GLOBAL_ZERO)
12353             {
12354               log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12355
12356               continue;
12357             }
12358
12359             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);
12360
12361             if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12362             if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12363
12364             hashes_cnt++;
12365           }
12366         }
12367
12368         myfree (line_buf);
12369
12370         fclose (fp);
12371
12372         if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12373
12374         if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12375       }
12376     }
12377     else
12378     {
12379       if (isSalted)
12380       {
12381         hashes_buf[0].salt->salt_len = 8;
12382
12383         // special salt handling
12384
12385         switch (hash_mode)
12386         {
12387           case  1500: hashes_buf[0].salt->salt_len    = 2;
12388                       hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12389                       break;
12390           case  1731: hashes_buf[0].salt->salt_len = 4;
12391                       break;
12392           case  2410: hashes_buf[0].salt->salt_len = 4;
12393                       break;
12394           case  2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12395                       break;
12396           case  3100: hashes_buf[0].salt->salt_len = 1;
12397                       break;
12398           case  5000: hashes_buf[0].salt->keccak_mdlen = 32;
12399                       break;
12400           case  5800: hashes_buf[0].salt->salt_len = 16;
12401                       break;
12402           case  6800: hashes_buf[0].salt->salt_len = 32;
12403                       break;
12404           case  8400: hashes_buf[0].salt->salt_len = 40;
12405                       break;
12406           case  8800: hashes_buf[0].salt->salt_len = 16;
12407                       break;
12408           case  8900: hashes_buf[0].salt->salt_len = 16;
12409                       hashes_buf[0].salt->scrypt_N = 1024;
12410                       hashes_buf[0].salt->scrypt_r = 1;
12411                       hashes_buf[0].salt->scrypt_p = 1;
12412                       break;
12413           case  9100: hashes_buf[0].salt->salt_len = 16;
12414                       break;
12415           case  9300: hashes_buf[0].salt->salt_len = 14;
12416                       hashes_buf[0].salt->scrypt_N = 16384;
12417                       hashes_buf[0].salt->scrypt_r = 1;
12418                       hashes_buf[0].salt->scrypt_p = 1;
12419                       break;
12420           case  9400: hashes_buf[0].salt->salt_len = 16;
12421                       break;
12422           case  9500: hashes_buf[0].salt->salt_len = 16;
12423                       break;
12424           case  9600: hashes_buf[0].salt->salt_len = 16;
12425                       break;
12426           case  9700: hashes_buf[0].salt->salt_len = 16;
12427                       break;
12428           case  9710: hashes_buf[0].salt->salt_len = 16;
12429                       break;
12430           case  9720: hashes_buf[0].salt->salt_len = 16;
12431                       break;
12432           case  9800: hashes_buf[0].salt->salt_len = 16;
12433                       break;
12434           case  9810: hashes_buf[0].salt->salt_len = 16;
12435                       break;
12436           case  9820: hashes_buf[0].salt->salt_len = 16;
12437                       break;
12438           case 10300: hashes_buf[0].salt->salt_len = 12;
12439                       break;
12440           case 11500: hashes_buf[0].salt->salt_len = 4;
12441                       break;
12442           case 11600: hashes_buf[0].salt->salt_len = 4;
12443                       break;
12444           case 12400: hashes_buf[0].salt->salt_len = 4;
12445                       break;
12446           case 12500: hashes_buf[0].salt->salt_len = 8;
12447                       break;
12448           case 12600: hashes_buf[0].salt->salt_len = 64;
12449                       break;
12450         }
12451
12452         // special esalt handling
12453
12454         switch (hash_mode)
12455         {
12456           case  2500: ((wpa_t *)     hashes_buf[0].esalt)->eapol_size   = 128;
12457                       break;
12458           case  5300: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12459                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12460                       break;
12461           case  5400: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12462                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12463                       break;
12464           case  5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12465                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12466                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12467                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12468                       break;
12469           case  5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12470                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12471                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12472                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12473                       break;
12474           case  7300: ((rakp_t *)    hashes_buf[0].esalt)->salt_len     = 32;
12475                       break;
12476           case 10400: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12477                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12478                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12479                       break;
12480           case 10410: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12481                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12482                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12483                       break;
12484           case 10420: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12485                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12486                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12487                       break;
12488           case 10500: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12489                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12490                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12491                       break;
12492           case 10600: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12493                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12494                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12495                       break;
12496           case 10700: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12497                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12498                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12499                       break;
12500           case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len      = 16;
12501                       ((seven_zip_t *) hashes_buf[0].esalt)->data_len    = 112;
12502                       ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12503                       break;
12504           case 13400: ((keepass_t *) hashes_buf[0].esalt)->version      = 2;
12505                       break;
12506           case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len     = 113;
12507                       break;
12508           case 13600: ((zip2_t *)    hashes_buf[0].esalt)->salt_len     = 16;
12509                       ((zip2_t *)    hashes_buf[0].esalt)->data_len     = 32;
12510                       ((zip2_t *)    hashes_buf[0].esalt)->mode         = 3;
12511                       break;
12512         }
12513       }
12514
12515       // set hashfile
12516
12517       switch (hash_mode)
12518       {
12519         case 5200:  data.hashfile = mystrdup ("hashcat.psafe3");
12520                     break;
12521         case 5300:  data.hashfile = mystrdup ("hashcat.ikemd5");
12522                     break;
12523         case 5400:  data.hashfile = mystrdup ("hashcat.ikesha1");
12524                     break;
12525         case 6211:  data.hashfile = mystrdup ("hashcat.tc");
12526                     break;
12527         case 6212:  data.hashfile = mystrdup ("hashcat.tc");
12528                     break;
12529         case 6213:  data.hashfile = mystrdup ("hashcat.tc");
12530                     break;
12531         case 6221:  data.hashfile = mystrdup ("hashcat.tc");
12532                     break;
12533         case 6222:  data.hashfile = mystrdup ("hashcat.tc");
12534                     break;
12535         case 6223:  data.hashfile = mystrdup ("hashcat.tc");
12536                     break;
12537         case 6231:  data.hashfile = mystrdup ("hashcat.tc");
12538                     break;
12539         case 6232:  data.hashfile = mystrdup ("hashcat.tc");
12540                     break;
12541         case 6233:  data.hashfile = mystrdup ("hashcat.tc");
12542                     break;
12543         case 6241:  data.hashfile = mystrdup ("hashcat.tc");
12544                     break;
12545         case 6242:  data.hashfile = mystrdup ("hashcat.tc");
12546                     break;
12547         case 6243:  data.hashfile = mystrdup ("hashcat.tc");
12548                     break;
12549         case 6600:  data.hashfile = mystrdup ("hashcat.agilekey");
12550                     break;
12551         case 8200:  data.hashfile = mystrdup ("hashcat.cloudkey");
12552                     break;
12553         case 9000:  data.hashfile = mystrdup ("hashcat.psafe2");
12554                     break;
12555         case 13711: data.hashfile = mystrdup ("hashcat.vc");
12556                     break;
12557         case 13712: data.hashfile = mystrdup ("hashcat.vc");
12558                     break;
12559         case 13713: data.hashfile = mystrdup ("hashcat.vc");
12560                     break;
12561         case 13721: data.hashfile = mystrdup ("hashcat.vc");
12562                     break;
12563         case 13722: data.hashfile = mystrdup ("hashcat.vc");
12564                     break;
12565         case 13723: data.hashfile = mystrdup ("hashcat.vc");
12566                     break;
12567         case 13731: data.hashfile = mystrdup ("hashcat.vc");
12568                     break;
12569         case 13732: data.hashfile = mystrdup ("hashcat.vc");
12570                     break;
12571         case 13733: data.hashfile = mystrdup ("hashcat.vc");
12572                     break;
12573         case 13741: data.hashfile = mystrdup ("hashcat.vc");
12574                     break;
12575         case 13742: data.hashfile = mystrdup ("hashcat.vc");
12576                     break;
12577         case 13743: data.hashfile = mystrdup ("hashcat.vc");
12578                     break;
12579         case 13751: data.hashfile = mystrdup ("hashcat.vc");
12580                     break;
12581         case 13752: data.hashfile = mystrdup ("hashcat.vc");
12582                     break;
12583         case 13753: data.hashfile = mystrdup ("hashcat.vc");
12584                     break;
12585         case 13761: data.hashfile = mystrdup ("hashcat.vc");
12586                     break;
12587         case 13762: data.hashfile = mystrdup ("hashcat.vc");
12588                     break;
12589         case 13763: data.hashfile = mystrdup ("hashcat.vc");
12590                     break;
12591       }
12592
12593       // set default iterations
12594
12595       switch (hash_mode)
12596       {
12597         case   400:  hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12598                      break;
12599         case   500:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12600                      break;
12601         case   501:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12602                      break;
12603         case  1600:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12604                      break;
12605         case  1800:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12606                      break;
12607         case  2100:  hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12608                      break;
12609         case  2500:  hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12610                      break;
12611         case  3200:  hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12612                      break;
12613         case  5200:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12614                      break;
12615         case  5800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12616                      break;
12617         case  6211:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12618                      break;
12619         case  6212:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12620                      break;
12621         case  6213:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12622                      break;
12623         case  6221:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12624                      break;
12625         case  6222:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12626                      break;
12627         case  6223:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12628                      break;
12629         case  6231:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12630                      break;
12631         case  6232:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12632                      break;
12633         case  6233:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12634                      break;
12635         case  6241:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12636                      break;
12637         case  6242:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12638                      break;
12639         case  6243:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12640                      break;
12641         case  6300:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12642                      break;
12643         case  6400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12644                      break;
12645         case  6500:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12646                      break;
12647         case  6700:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12648                      break;
12649         case  6600:  hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12650                      break;
12651         case  6800:  hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12652                      break;
12653         case  7100:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12654                      break;
12655         case  7200:  hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12656                      break;
12657         case  7400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12658                      break;
12659         case  7900:  hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12660                      break;
12661         case  8200:  hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12662                      break;
12663         case  8300:  hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12664                      break;
12665         case  8800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12666                      break;
12667         case  8900:  hashes_buf[0].salt->salt_iter = 1;
12668                      break;
12669         case  9000:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12670                      break;
12671         case  9100:  hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12672                      break;
12673         case  9200:  hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12674                      break;
12675         case  9300:  hashes_buf[0].salt->salt_iter = 1;
12676                      break;
12677         case  9400:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12678                      break;
12679         case  9500:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12680                      break;
12681         case  9600:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12682                      break;
12683         case 10000:  hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12684                      break;
12685         case 10300:  hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12686                      break;
12687         case 10500:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12688                      break;
12689         case 10700:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12690                      break;
12691         case 10900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12692                      break;
12693         case 11300:  hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12694                      break;
12695         case 11600:  hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12696                      break;
12697         case 11900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12698                      break;
12699         case 12000:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12700                      break;
12701         case 12100:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12702                      break;
12703         case 12200:  hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12704                      break;
12705         case 12300:  hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12706                      break;
12707         case 12400:  hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12708                      break;
12709         case 12500:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12710                      break;
12711         case 12700:  hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12712                      break;
12713         case 12800:  hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12714                      break;
12715         case 12900:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12716                      break;
12717         case 13000:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12718                      break;
12719         case 13200:  hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12720                      break;
12721         case 13400:  hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12722                      break;
12723         case 13600:  hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12724                      break;
12725         case 13711:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12726                      break;
12727         case 13712:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12728                      break;
12729         case 13713:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12730                      break;
12731         case 13721:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12732                      break;
12733         case 13722:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12734                      break;
12735         case 13723:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12736                      break;
12737         case 13731:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12738                      break;
12739         case 13732:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12740                      break;
12741         case 13733:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12742                      break;
12743         case 13741:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12744                      break;
12745         case 13742:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12746                      break;
12747         case 13743:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12748                      break;
12749         case 13751:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12750                      break;
12751         case 13752:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12752                      break;
12753         case 13753:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12754                      break;
12755         case 13761:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12756                      break;
12757         case 13762:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12758                      break;
12759         case 13763:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12760                      break;
12761       }
12762
12763       hashes_cnt = 1;
12764     }
12765
12766     if (show == 1 || left == 1)
12767     {
12768       for (uint i = 0; i < pot_cnt; i++)
12769       {
12770         pot_t *pot_ptr = &pot[i];
12771
12772         hash_t *hashes_buf = &pot_ptr->hash;
12773
12774         local_free (hashes_buf->digest);
12775
12776         if (isSalted)
12777         {
12778           local_free (hashes_buf->salt);
12779         }
12780       }
12781
12782       local_free (pot);
12783
12784       if (data.quiet == 0) log_info_nn ("");
12785
12786       return (0);
12787     }
12788
12789     if ((keyspace == 0) && (stdout_flag == 0))
12790     {
12791       if (hashes_cnt == 0)
12792       {
12793         log_error ("ERROR: No hashes loaded");
12794
12795         return (-1);
12796       }
12797     }
12798
12799     /**
12800      * Sanity check for hashfile vs outfile (should not point to the same physical file)
12801      */
12802
12803     if (data.outfile != NULL)
12804     {
12805       if (data.hashfile != NULL)
12806       {
12807         #ifdef _POSIX
12808         struct stat tmpstat_outfile;
12809         struct stat tmpstat_hashfile;
12810         #endif
12811
12812         #ifdef _WIN
12813         struct stat64 tmpstat_outfile;
12814         struct stat64 tmpstat_hashfile;
12815         #endif
12816
12817         FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12818
12819         if (tmp_outfile_fp)
12820         {
12821           #ifdef _POSIX
12822           fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12823           #endif
12824
12825           #ifdef _WIN
12826           _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12827           #endif
12828
12829           fclose (tmp_outfile_fp);
12830         }
12831
12832         FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12833
12834         if (tmp_hashfile_fp)
12835         {
12836           #ifdef _POSIX
12837           fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12838           #endif
12839
12840           #ifdef _WIN
12841           _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12842           #endif
12843
12844           fclose (tmp_hashfile_fp);
12845         }
12846
12847         if (tmp_outfile_fp && tmp_outfile_fp)
12848         {
12849           tmpstat_outfile.st_mode     = 0;
12850           tmpstat_outfile.st_nlink    = 0;
12851           tmpstat_outfile.st_uid      = 0;
12852           tmpstat_outfile.st_gid      = 0;
12853           tmpstat_outfile.st_rdev     = 0;
12854           tmpstat_outfile.st_atime    = 0;
12855
12856           tmpstat_hashfile.st_mode    = 0;
12857           tmpstat_hashfile.st_nlink   = 0;
12858           tmpstat_hashfile.st_uid     = 0;
12859           tmpstat_hashfile.st_gid     = 0;
12860           tmpstat_hashfile.st_rdev    = 0;
12861           tmpstat_hashfile.st_atime   = 0;
12862
12863           #ifdef _POSIX
12864           tmpstat_outfile.st_blksize  = 0;
12865           tmpstat_outfile.st_blocks   = 0;
12866
12867           tmpstat_hashfile.st_blksize = 0;
12868           tmpstat_hashfile.st_blocks  = 0;
12869           #endif
12870
12871           #ifdef _POSIX
12872           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12873           {
12874             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12875
12876             return (-1);
12877           }
12878           #endif
12879
12880           #ifdef _WIN
12881           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12882           {
12883             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12884
12885             return (-1);
12886           }
12887           #endif
12888         }
12889       }
12890     }
12891
12892     /**
12893      * Remove duplicates
12894      */
12895
12896     if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12897
12898     if (isSalted)
12899     {
12900       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12901     }
12902     else
12903     {
12904       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12905     }
12906
12907     uint hashes_cnt_orig = hashes_cnt;
12908
12909     hashes_cnt = 1;
12910
12911     for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12912     {
12913       if (isSalted)
12914       {
12915         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12916         {
12917           if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12918         }
12919       }
12920       else
12921       {
12922         if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12923       }
12924
12925       if (hashes_pos > hashes_cnt)
12926       {
12927         memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12928       }
12929
12930       hashes_cnt++;
12931     }
12932
12933     /**
12934      * Potfile removes
12935      */
12936
12937     uint potfile_remove_cracks = 0;
12938
12939     if (potfile_disable == 0)
12940     {
12941       hash_t hash_buf;
12942
12943       hash_buf.digest    = mymalloc (dgst_size);
12944       hash_buf.salt      = NULL;
12945       hash_buf.esalt     = NULL;
12946       hash_buf.hash_info = NULL;
12947       hash_buf.cracked   = 0;
12948
12949       if (isSalted)
12950       {
12951         hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12952       }
12953
12954       if (esalt_size)
12955       {
12956         hash_buf.esalt = mymalloc (esalt_size);
12957       }
12958
12959       if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12960
12961       // no solution for these special hash types (for instane because they use hashfile in output etc)
12962       if ((hash_mode != 5200) &&
12963           !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
12964           !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12965           (hash_mode != 9000))
12966       {
12967         FILE *fp = fopen (potfile, "rb");
12968
12969         if (fp != NULL)
12970         {
12971           char *line_buf = (char *) mymalloc (HCBUFSIZ);
12972
12973           // to be safe work with a copy (because of line_len loop, i etc)
12974           // moved up here because it's easier to handle continue case
12975           // it's just 64kb
12976
12977           char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12978
12979           while (!feof (fp))
12980           {
12981             char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12982
12983             if (ptr == NULL) break;
12984
12985             int line_len = strlen (line_buf);
12986
12987             if (line_len == 0) continue;
12988
12989             int iter = MAX_CUT_TRIES;
12990
12991             for (int i = line_len - 1; i && iter; i--, line_len--)
12992             {
12993               if (line_buf[i] != ':') continue;
12994
12995               if (isSalted)
12996               {
12997                 memset (hash_buf.salt, 0, sizeof (salt_t));
12998               }
12999
13000               hash_t *found = NULL;
13001
13002               if (hash_mode == 6800)
13003               {
13004                 if (i < 64) // 64 = 16 * uint in salt_buf[]
13005                 {
13006                   // manipulate salt_buf
13007                   memcpy (hash_buf.salt->salt_buf, line_buf, i);
13008
13009                   hash_buf.salt->salt_len = i;
13010
13011                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13012                 }
13013               }
13014               else if (hash_mode == 2500)
13015               {
13016                 if (i < 64) // 64 = 16 * uint in salt_buf[]
13017                 {
13018                   // here we have in line_buf: ESSID:MAC1:MAC2   (without the plain)
13019                   // manipulate salt_buf
13020
13021                   memset (line_buf_cpy, 0, HCBUFSIZ);
13022                   memcpy (line_buf_cpy, line_buf, i);
13023
13024                   char *mac2_pos = strrchr (line_buf_cpy, ':');
13025
13026                   if (mac2_pos == NULL) continue;
13027
13028                   mac2_pos[0] = 0;
13029                   mac2_pos++;
13030
13031                   if (strlen (mac2_pos) != 12) continue;
13032
13033                   char *mac1_pos = strrchr (line_buf_cpy, ':');
13034
13035                   if (mac1_pos == NULL) continue;
13036
13037                   mac1_pos[0] = 0;
13038                   mac1_pos++;
13039
13040                   if (strlen (mac1_pos) != 12) continue;
13041
13042                   uint essid_length = mac1_pos - line_buf_cpy - 1;
13043
13044                   // here we need the ESSID
13045                   memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13046
13047                   hash_buf.salt->salt_len = essid_length;
13048
13049                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13050
13051                   if (found)
13052                   {
13053                     wpa_t *wpa = (wpa_t *) found->esalt;
13054
13055                     // compare hex string(s) vs binary MAC address(es)
13056
13057                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13058                     {
13059                       if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13060                       {
13061                         found = NULL;
13062
13063                         break;
13064                       }
13065                     }
13066
13067                     // early skip ;)
13068                     if (!found) continue;
13069
13070                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13071                     {
13072                       if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13073                       {
13074                         found = NULL;
13075
13076                         break;
13077                       }
13078                     }
13079                   }
13080                 }
13081               }
13082               else
13083               {
13084                 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13085
13086                 if (parser_status == PARSER_OK)
13087                 {
13088                   if (isSalted)
13089                   {
13090                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13091                   }
13092                   else
13093                   {
13094                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13095                   }
13096                 }
13097               }
13098
13099               if (found == NULL) continue;
13100
13101               if (!found->cracked) potfile_remove_cracks++;
13102
13103               found->cracked = 1;
13104
13105               if (found) break;
13106
13107               iter--;
13108             }
13109           }
13110
13111           myfree (line_buf_cpy);
13112
13113           myfree (line_buf);
13114
13115           fclose (fp);
13116         }
13117       }
13118
13119       if (esalt_size)
13120       {
13121         local_free (hash_buf.esalt);
13122       }
13123
13124       if (isSalted)
13125       {
13126         local_free (hash_buf.salt);
13127       }
13128
13129       local_free (hash_buf.digest);
13130     }
13131
13132     /**
13133      * Now generate all the buffers required for later
13134      */
13135
13136     void   *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13137
13138     salt_t *salts_buf_new  = NULL;
13139     void   *esalts_buf_new = NULL;
13140
13141     if (isSalted)
13142     {
13143       salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13144
13145       if (esalt_size)
13146       {
13147         esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13148       }
13149     }
13150     else
13151     {
13152       salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13153     }
13154
13155     if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13156
13157     uint digests_cnt  = hashes_cnt;
13158     uint digests_done = 0;
13159
13160     size_t size_digests = digests_cnt * dgst_size;
13161     size_t size_shown   = digests_cnt * sizeof (uint);
13162
13163     uint *digests_shown     = (uint *) mymalloc (size_shown);
13164     uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13165
13166     uint salts_cnt   = 0;
13167     uint salts_done  = 0;
13168
13169     hashinfo_t **hash_info = NULL;
13170
13171     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13172     {
13173       hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13174
13175       if (username && (remove || show))
13176       {
13177         uint user_pos;
13178
13179         for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13180         {
13181           hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13182
13183           hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13184         }
13185       }
13186     }
13187
13188     uint *salts_shown = (uint *) mymalloc (size_shown);
13189
13190     salt_t *salt_buf;
13191
13192     {
13193       // copied from inner loop
13194
13195       salt_buf = &salts_buf_new[salts_cnt];
13196
13197       memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13198
13199       if (esalt_size)
13200       {
13201         memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13202       }
13203
13204       salt_buf->digests_cnt    = 0;
13205       salt_buf->digests_done   = 0;
13206       salt_buf->digests_offset = 0;
13207
13208       salts_cnt++;
13209     }
13210
13211     if (hashes_buf[0].cracked == 1)
13212     {
13213       digests_shown[0] = 1;
13214
13215       digests_done++;
13216
13217       salt_buf->digests_done++;
13218     }
13219
13220     salt_buf->digests_cnt++;
13221
13222     memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13223
13224     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13225     {
13226       hash_info[0] = hashes_buf[0].hash_info;
13227     }
13228
13229     // copy from inner loop
13230
13231     for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13232     {
13233       if (isSalted)
13234       {
13235         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13236         {
13237           salt_buf = &salts_buf_new[salts_cnt];
13238
13239           memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13240
13241           if (esalt_size)
13242           {
13243             memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13244           }
13245
13246           salt_buf->digests_cnt    = 0;
13247           salt_buf->digests_done   = 0;
13248           salt_buf->digests_offset = hashes_pos;
13249
13250           salts_cnt++;
13251         }
13252       }
13253
13254       if (hashes_buf[hashes_pos].cracked == 1)
13255       {
13256         digests_shown[hashes_pos] = 1;
13257
13258         digests_done++;
13259
13260         salt_buf->digests_done++;
13261       }
13262
13263       salt_buf->digests_cnt++;
13264
13265       memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13266
13267       if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13268       {
13269         hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13270       }
13271     }
13272
13273     for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13274     {
13275       salt_t *salt_buf = &salts_buf_new[salt_pos];
13276
13277       if (salt_buf->digests_done == salt_buf->digests_cnt)
13278       {
13279         salts_shown[salt_pos] = 1;
13280
13281         salts_done++;
13282       }
13283
13284       if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13285     }
13286
13287     local_free (digests_buf);
13288     local_free (salts_buf);
13289     local_free (esalts_buf);
13290
13291     digests_buf = digests_buf_new;
13292     salts_buf   = salts_buf_new;
13293     esalts_buf  = esalts_buf_new;
13294
13295     local_free (hashes_buf);
13296
13297     /**
13298      * special modification not set from parser
13299      */
13300
13301     switch (hash_mode)
13302     {
13303       case  6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13304       case  6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13305       case  6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13306       case  6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13307       case  6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13308       case  6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13309       case  6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13310       case  6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13311       case  6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13312       case  6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13313       case  6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13314       case  6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13315       case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13316       case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13317       case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13318       case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13319       case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13320       case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13321       case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13322       case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13323       case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13324       case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13325       case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13326       case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13327       case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13328       case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13329       case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13330       case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13331       case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13332       case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13333     }
13334
13335     if (truecrypt_keyfiles)
13336     {
13337       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13338
13339       char *keyfiles = strdup (truecrypt_keyfiles);
13340
13341       char *keyfile = strtok (keyfiles, ",");
13342
13343       do
13344       {
13345         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13346
13347       } while ((keyfile = strtok (NULL, ",")) != NULL);
13348
13349       free (keyfiles);
13350     }
13351
13352     if (veracrypt_keyfiles)
13353     {
13354       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13355
13356       char *keyfiles = strdup (veracrypt_keyfiles);
13357
13358       char *keyfile = strtok (keyfiles, ",");
13359
13360       do
13361       {
13362         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13363
13364       } while ((keyfile = strtok (NULL, ",")) != NULL);
13365
13366       free (keyfiles);
13367     }
13368
13369     data.digests_cnt        = digests_cnt;
13370     data.digests_done       = digests_done;
13371     data.digests_buf        = digests_buf;
13372     data.digests_shown      = digests_shown;
13373     data.digests_shown_tmp  = digests_shown_tmp;
13374
13375     data.salts_cnt          = salts_cnt;
13376     data.salts_done         = salts_done;
13377     data.salts_buf          = salts_buf;
13378     data.salts_shown        = salts_shown;
13379
13380     data.esalts_buf         = esalts_buf;
13381     data.hash_info          = hash_info;
13382
13383     /**
13384      * Automatic Optimizers
13385      */
13386
13387     if (salts_cnt == 1)
13388       opti_type |= OPTI_TYPE_SINGLE_SALT;
13389
13390     if (digests_cnt == 1)
13391       opti_type |= OPTI_TYPE_SINGLE_HASH;
13392
13393     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13394       opti_type |= OPTI_TYPE_NOT_ITERATED;
13395
13396     if (attack_mode == ATTACK_MODE_BF)
13397       opti_type |= OPTI_TYPE_BRUTE_FORCE;
13398
13399     data.opti_type = opti_type;
13400
13401     if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13402     {
13403       if (opti_type & OPTI_TYPE_SINGLE_HASH)
13404       {
13405         if (opti_type & OPTI_TYPE_APPENDED_SALT)
13406         {
13407           if (opts_type & OPTS_TYPE_ST_ADD80)
13408           {
13409             opts_type &= ~OPTS_TYPE_ST_ADD80;
13410             opts_type |=  OPTS_TYPE_PT_ADD80;
13411           }
13412
13413           if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13414           {
13415             opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13416             opts_type |=  OPTS_TYPE_PT_ADDBITS14;
13417           }
13418
13419           if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13420           {
13421             opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13422             opts_type |=  OPTS_TYPE_PT_ADDBITS15;
13423           }
13424         }
13425       }
13426     }
13427
13428     /**
13429      * Some algorithm, like descrypt, can benefit from JIT compilation
13430      */
13431
13432     int force_jit_compilation = -1;
13433
13434     if (hash_mode == 8900)
13435     {
13436       force_jit_compilation = 8900;
13437     }
13438     else if (hash_mode == 9300)
13439     {
13440       force_jit_compilation = 8900;
13441     }
13442     else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13443     {
13444       force_jit_compilation = 1500;
13445     }
13446
13447     /**
13448      * generate bitmap tables
13449      */
13450
13451     const uint bitmap_shift1 = 5;
13452     const uint bitmap_shift2 = 13;
13453
13454     if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13455
13456     uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13457     uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13458     uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13459     uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13460     uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13461     uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13462     uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13463     uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13464
13465     uint bitmap_bits;
13466     uint bitmap_nums;
13467     uint bitmap_mask;
13468     uint bitmap_size;
13469
13470     for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13471     {
13472       if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13473
13474       bitmap_nums = 1 << bitmap_bits;
13475
13476       bitmap_mask = bitmap_nums - 1;
13477
13478       bitmap_size = bitmap_nums * sizeof (uint);
13479
13480       if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13481
13482       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;
13483       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;
13484
13485       break;
13486     }
13487
13488     bitmap_nums = 1 << bitmap_bits;
13489
13490     bitmap_mask = bitmap_nums - 1;
13491
13492     bitmap_size = bitmap_nums * sizeof (uint);
13493
13494     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);
13495     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);
13496
13497     /**
13498      * prepare quick rule
13499      */
13500
13501     data.rule_buf_l = rule_buf_l;
13502     data.rule_buf_r = rule_buf_r;
13503
13504     int rule_len_l = (int) strlen (rule_buf_l);
13505     int rule_len_r = (int) strlen (rule_buf_r);
13506
13507     data.rule_len_l = rule_len_l;
13508     data.rule_len_r = rule_len_r;
13509
13510     /**
13511      * load rules
13512      */
13513
13514     uint *all_kernel_rules_cnt = NULL;
13515
13516     kernel_rule_t **all_kernel_rules_buf = NULL;
13517
13518     if (rp_files_cnt)
13519     {
13520       all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13521
13522       all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13523     }
13524
13525     char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13526
13527     int rule_len = 0;
13528
13529     for (uint i = 0; i < rp_files_cnt; i++)
13530     {
13531       uint kernel_rules_avail = 0;
13532
13533       uint kernel_rules_cnt = 0;
13534
13535       kernel_rule_t *kernel_rules_buf = NULL;
13536
13537       char *rp_file = rp_files[i];
13538
13539       char in[BLOCK_SIZE]  = { 0 };
13540       char out[BLOCK_SIZE] = { 0 };
13541
13542       FILE *fp = NULL;
13543
13544       uint rule_line = 0;
13545
13546       if ((fp = fopen (rp_file, "rb")) == NULL)
13547       {
13548         log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13549
13550         return (-1);
13551       }
13552
13553       while (!feof (fp))
13554       {
13555         memset (rule_buf, 0, HCBUFSIZ);
13556
13557         rule_len = fgetl (fp, rule_buf);
13558
13559         rule_line++;
13560
13561         if (rule_len == 0) continue;
13562
13563         if (rule_buf[0] == '#') continue;
13564
13565         if (kernel_rules_avail == kernel_rules_cnt)
13566         {
13567           kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13568
13569           kernel_rules_avail += INCR_RULES;
13570         }
13571
13572         memset (in,  0, BLOCK_SIZE);
13573         memset (out, 0, BLOCK_SIZE);
13574
13575         int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13576
13577         if (result == -1)
13578         {
13579           log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13580
13581           continue;
13582         }
13583
13584         if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13585         {
13586           log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13587
13588           memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13589
13590           continue;
13591         }
13592
13593         /* its so slow
13594         if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13595         {
13596           log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13597
13598           continue;
13599         }
13600         */
13601
13602         kernel_rules_cnt++;
13603       }
13604
13605       fclose (fp);
13606
13607       all_kernel_rules_cnt[i] = kernel_rules_cnt;
13608
13609       all_kernel_rules_buf[i] = kernel_rules_buf;
13610     }
13611
13612     /**
13613      * merge rules or automatic rule generator
13614      */
13615
13616     uint kernel_rules_cnt = 0;
13617
13618     kernel_rule_t *kernel_rules_buf = NULL;
13619
13620     if (attack_mode == ATTACK_MODE_STRAIGHT)
13621     {
13622       if (rp_files_cnt)
13623       {
13624         kernel_rules_cnt = 1;
13625
13626         uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13627
13628         repeats[0] = kernel_rules_cnt;
13629
13630         for (uint i = 0; i < rp_files_cnt; i++)
13631         {
13632           kernel_rules_cnt *= all_kernel_rules_cnt[i];
13633
13634           repeats[i + 1] = kernel_rules_cnt;
13635         }
13636
13637         kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13638
13639         memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13640
13641         for (uint i = 0; i < kernel_rules_cnt; i++)
13642         {
13643           uint out_pos = 0;
13644
13645           kernel_rule_t *out = &kernel_rules_buf[i];
13646
13647           for (uint j = 0; j < rp_files_cnt; j++)
13648           {
13649             uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13650             uint in_pos;
13651
13652             kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13653
13654             for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13655             {
13656               if (out_pos == RULES_MAX - 1)
13657               {
13658                 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13659
13660                 break;
13661               }
13662
13663               out->cmds[out_pos] = in->cmds[in_pos];
13664             }
13665           }
13666         }
13667
13668         local_free (repeats);
13669       }
13670       else if (rp_gen)
13671       {
13672         uint kernel_rules_avail = 0;
13673
13674         while (kernel_rules_cnt < rp_gen)
13675         {
13676           if (kernel_rules_avail == kernel_rules_cnt)
13677           {
13678             kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13679
13680             kernel_rules_avail += INCR_RULES;
13681           }
13682
13683           memset (rule_buf, 0, HCBUFSIZ);
13684
13685           rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13686
13687           if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13688
13689           kernel_rules_cnt++;
13690         }
13691       }
13692     }
13693
13694     myfree (rule_buf);
13695
13696     /**
13697      * generate NOP rules
13698      */
13699
13700     if ((rp_files_cnt == 0) && (rp_gen == 0))
13701     {
13702       kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13703
13704       kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13705
13706       kernel_rules_cnt++;
13707     }
13708
13709     data.kernel_rules_cnt = kernel_rules_cnt;
13710     data.kernel_rules_buf = kernel_rules_buf;
13711
13712     if (kernel_rules_cnt == 0)
13713     {
13714       log_error ("ERROR: No valid rules left");
13715
13716       return (-1);
13717     }
13718
13719     /**
13720      * OpenCL platforms: detect
13721      */
13722
13723     cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13724     cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13725
13726     cl_uint platforms_cnt = 0;
13727     cl_uint platform_devices_cnt = 0;
13728
13729     if (keyspace == 0)
13730     {
13731       hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13732
13733       if (platforms_cnt == 0)
13734       {
13735         log_info ("");
13736         log_info ("ATTENTION! No OpenCL compatible platform found");
13737         log_info ("");
13738         log_info ("You're probably missing the OpenCL runtime installation");
13739         log_info ("  AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13740         log_info ("  Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13741         log_info ("  NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13742         log_info ("");
13743
13744         return (-1);
13745       }
13746
13747       if (opencl_platforms_filter != (uint) -1)
13748       {
13749         uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13750
13751         if (opencl_platforms_filter > platform_cnt_mask)
13752         {
13753           log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13754
13755           return (-1);
13756         }
13757       }
13758     }
13759
13760     if (opencl_device_types == NULL)
13761     {
13762       /**
13763        * OpenCL device types:
13764        *   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.
13765        */
13766
13767       cl_device_type device_types_all = 0;
13768
13769       for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13770       {
13771         if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13772
13773         cl_platform_id platform = platforms[platform_id];
13774
13775         hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13776
13777         for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13778         {
13779           cl_device_id device = platform_devices[platform_devices_id];
13780
13781           cl_device_type device_type;
13782
13783           hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13784
13785           device_types_all |= device_type;
13786         }
13787       }
13788
13789       // In such a case, automatically enable CPU device type support, since it's disabled by default.
13790
13791       if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13792       {
13793         device_types_filter |= CL_DEVICE_TYPE_CPU;
13794       }
13795
13796       // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13797       // If we have a CPU device, force it to be used
13798
13799       if (stdout_flag == 1)
13800       {
13801         if (device_types_all & CL_DEVICE_TYPE_CPU)
13802         {
13803           device_types_filter = CL_DEVICE_TYPE_CPU;
13804         }
13805       }
13806     }
13807
13808     /**
13809      * OpenCL devices: simply push all devices from all platforms into the same device array
13810      */
13811
13812     int need_adl     = 0;
13813     int need_nvapi   = 0;
13814     int need_nvml    = 0;
13815     int need_xnvctrl = 0;
13816
13817     hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13818
13819     data.devices_param = devices_param;
13820
13821     uint devices_cnt = 0;
13822
13823     uint devices_active = 0;
13824
13825     for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13826     {
13827       cl_platform_id platform = platforms[platform_id];
13828
13829       hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13830
13831       char platform_vendor[INFOSZ] = { 0 };
13832
13833       hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13834
13835       // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13836       // this causes trouble with vendor id based macros
13837       // we'll assign generic to those without special optimization available
13838
13839       cl_uint platform_vendor_id = 0;
13840
13841       if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13842       {
13843         platform_vendor_id = VENDOR_ID_AMD;
13844       }
13845       else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13846       {
13847         platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13848       }
13849       else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13850       {
13851         platform_vendor_id = VENDOR_ID_APPLE;
13852       }
13853       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13854       {
13855         platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13856       }
13857       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13858       {
13859         platform_vendor_id = VENDOR_ID_INTEL_SDK;
13860       }
13861       else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13862       {
13863         platform_vendor_id = VENDOR_ID_MESA;
13864       }
13865       else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13866       {
13867         platform_vendor_id = VENDOR_ID_NV;
13868       }
13869       else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13870       {
13871         platform_vendor_id = VENDOR_ID_POCL;
13872       }
13873       else
13874       {
13875         platform_vendor_id = VENDOR_ID_GENERIC;
13876       }
13877
13878       const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13879
13880       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13881       {
13882         if (machine_readable == 0)
13883         {
13884           if (platform_skipped == 0)
13885           {
13886             const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13887
13888             char line[256] = { 0 };
13889
13890             for (int i = 0; i < len; i++) line[i] = '=';
13891
13892             log_info (line);
13893           }
13894           else
13895           {
13896             log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13897             log_info ("");
13898           }
13899         }
13900       }
13901
13902       if (platform_skipped == 1) continue;
13903
13904       for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13905       {
13906         size_t param_value_size = 0;
13907
13908         const uint device_id = devices_cnt;
13909
13910         hc_device_param_t *device_param = &data.devices_param[device_id];
13911
13912         device_param->platform_vendor_id = platform_vendor_id;
13913
13914         device_param->device = platform_devices[platform_devices_id];
13915
13916         device_param->device_id = device_id;
13917
13918         device_param->platform_devices_id = platform_devices_id;
13919
13920         // device_type
13921
13922         cl_device_type device_type;
13923
13924         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13925
13926         device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13927
13928         device_param->device_type = device_type;
13929
13930         // device_name
13931
13932         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13933
13934         char *device_name = (char *) mymalloc (param_value_size);
13935
13936         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13937
13938         device_param->device_name = device_name;
13939
13940         // device_vendor
13941
13942         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13943
13944         char *device_vendor = (char *) mymalloc (param_value_size);
13945
13946         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13947
13948         device_param->device_vendor = device_vendor;
13949
13950         cl_uint device_vendor_id = 0;
13951
13952         if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13953         {
13954           device_vendor_id = VENDOR_ID_AMD;
13955         }
13956         else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13957         {
13958           device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13959         }
13960         else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13961         {
13962           device_vendor_id = VENDOR_ID_APPLE;
13963         }
13964         else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13965         {
13966           device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13967         }
13968         else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13969         {
13970           device_vendor_id = VENDOR_ID_INTEL_SDK;
13971         }
13972         else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13973         {
13974           device_vendor_id = VENDOR_ID_MESA;
13975         }
13976         else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13977         {
13978           device_vendor_id = VENDOR_ID_NV;
13979         }
13980         else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13981         {
13982           device_vendor_id = VENDOR_ID_POCL;
13983         }
13984         else
13985         {
13986           device_vendor_id = VENDOR_ID_GENERIC;
13987         }
13988
13989         device_param->device_vendor_id = device_vendor_id;
13990
13991         // tuning db
13992
13993         tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13994
13995         // device_version
13996
13997         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13998
13999         char *device_version = (char *) mymalloc (param_value_size);
14000
14001         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14002
14003         device_param->device_version = device_version;
14004
14005         // device_opencl_version
14006
14007         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14008
14009         char *device_opencl_version = (char *) mymalloc (param_value_size);
14010
14011         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14012
14013         device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14014
14015         myfree (device_opencl_version);
14016
14017         // vector_width
14018
14019         cl_uint vector_width;
14020
14021         if (opencl_vector_width_chgd == 0)
14022         {
14023           if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14024           {
14025             if (opti_type & OPTI_TYPE_USES_BITS_64)
14026             {
14027               hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14028             }
14029             else
14030             {
14031               hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,  sizeof (vector_width), &vector_width, NULL);
14032             }
14033           }
14034           else
14035           {
14036             vector_width = (cl_uint) tuningdb_entry->vector_width;
14037           }
14038         }
14039         else
14040         {
14041           vector_width = opencl_vector_width;
14042         }
14043
14044         if (vector_width > 16) vector_width = 16;
14045
14046         device_param->vector_width = vector_width;
14047
14048         // max_compute_units
14049
14050         cl_uint device_processors;
14051
14052         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14053
14054         device_param->device_processors = device_processors;
14055
14056         // device_maxmem_alloc
14057         // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14058
14059         cl_ulong device_maxmem_alloc;
14060
14061         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14062
14063         device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14064
14065         // device_global_mem
14066
14067         cl_ulong device_global_mem;
14068
14069         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14070
14071         device_param->device_global_mem = device_global_mem;
14072
14073         // max_work_group_size
14074
14075         size_t device_maxworkgroup_size;
14076
14077         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14078
14079         device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14080
14081         // max_clock_frequency
14082
14083         cl_uint device_maxclock_frequency;
14084
14085         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14086
14087         device_param->device_maxclock_frequency = device_maxclock_frequency;
14088
14089         // device_endian_little
14090
14091         cl_bool device_endian_little;
14092
14093         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14094
14095         if (device_endian_little == CL_FALSE)
14096         {
14097           log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14098
14099           device_param->skipped = 1;
14100         }
14101
14102         // device_available
14103
14104         cl_bool device_available;
14105
14106         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14107
14108         if (device_available == CL_FALSE)
14109         {
14110           log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14111
14112           device_param->skipped = 1;
14113         }
14114
14115         // device_compiler_available
14116
14117         cl_bool device_compiler_available;
14118
14119         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14120
14121         if (device_compiler_available == CL_FALSE)
14122         {
14123           log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14124
14125           device_param->skipped = 1;
14126         }
14127
14128         // device_execution_capabilities
14129
14130         cl_device_exec_capabilities device_execution_capabilities;
14131
14132         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14133
14134         if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14135         {
14136           log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14137
14138           device_param->skipped = 1;
14139         }
14140
14141         // device_extensions
14142
14143         size_t device_extensions_size;
14144
14145         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14146
14147         char *device_extensions = mymalloc (device_extensions_size + 1);
14148
14149         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14150
14151         if (strstr (device_extensions, "base_atomics") == 0)
14152         {
14153           log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14154
14155           device_param->skipped = 1;
14156         }
14157
14158         if (strstr (device_extensions, "byte_addressable_store") == 0)
14159         {
14160           log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14161
14162           device_param->skipped = 1;
14163         }
14164
14165         myfree (device_extensions);
14166
14167         // device_local_mem_size
14168
14169         cl_ulong device_local_mem_size;
14170
14171         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14172
14173         if (device_local_mem_size < 32768)
14174         {
14175           log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14176
14177           device_param->skipped = 1;
14178         }
14179
14180         // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14181         // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14182         // This results in both utilizing it for 50%
14183         // However, Intel has much better SIMD control over their own hardware
14184         // It makes sense to give them full control over their own hardware
14185
14186         if (device_type & CL_DEVICE_TYPE_CPU)
14187         {
14188           if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14189           {
14190             if (data.force == 0)
14191             {
14192               if (algorithm_pos == 0)
14193               {
14194                 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14195                 log_info ("             You can use --force to override this but do not post error reports if you do so");
14196               }
14197
14198               device_param->skipped = 1;
14199             }
14200           }
14201         }
14202
14203         // skipped
14204
14205         device_param->skipped |= ((devices_filter      & (1 << device_id)) == 0);
14206         device_param->skipped |= ((device_types_filter & (device_type))    == 0);
14207
14208         // driver_version
14209
14210         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14211
14212         char *driver_version = (char *) mymalloc (param_value_size);
14213
14214         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14215
14216         device_param->driver_version = driver_version;
14217
14218         // device_name_chksum
14219
14220         char *device_name_chksum = (char *) mymalloc (INFOSZ);
14221
14222         #if __x86_64__
14223         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);
14224         #else
14225         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);
14226         #endif
14227
14228         uint device_name_digest[4] = { 0 };
14229
14230         md5_64 ((uint *) device_name_chksum, device_name_digest);
14231
14232         snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14233
14234         device_param->device_name_chksum = device_name_chksum;
14235
14236         // vendor specific
14237
14238         if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14239         {
14240           if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14241           {
14242             need_adl = 1;
14243           }
14244
14245           if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14246           {
14247             need_nvml = 1;
14248
14249             #ifdef LINUX
14250             need_xnvctrl = 1;
14251             #endif
14252
14253             #ifdef WIN
14254             need_nvapi = 1;
14255             #endif
14256           }
14257         }
14258
14259         if (device_type & CL_DEVICE_TYPE_GPU)
14260         {
14261           if (device_vendor_id == VENDOR_ID_NV)
14262           {
14263             cl_uint kernel_exec_timeout = 0;
14264
14265             #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV            0x4005
14266
14267             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14268
14269             device_param->kernel_exec_timeout = kernel_exec_timeout;
14270
14271             cl_uint sm_minor = 0;
14272             cl_uint sm_major = 0;
14273
14274             #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV       0x4000
14275             #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV       0x4001
14276
14277             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14278             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14279
14280             device_param->sm_minor = sm_minor;
14281             device_param->sm_major = sm_major;
14282
14283             // CPU burning loop damper
14284             // Value is given as number between 0-100
14285             // By default 100%
14286
14287             device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14288
14289             if (nvidia_spin_damp_chgd == 0)
14290             {
14291               if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14292               {
14293                 /**
14294                  * the workaround is not a friend of rule based attacks
14295                  * the words from the wordlist combined with fast and slow rules cause
14296                  * fluctuations which cause inaccurate wait time estimations
14297                  * using a reduced damping percentage almost compensates this
14298                  */
14299
14300                 device_param->nvidia_spin_damp = 64;
14301               }
14302             }
14303
14304             device_param->nvidia_spin_damp /= 100;
14305           }
14306         }
14307
14308         // display results
14309
14310         if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14311         {
14312           if (machine_readable == 0)
14313           {
14314             if (device_param->skipped == 0)
14315             {
14316               log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14317                         device_id + 1,
14318                         device_name,
14319                         (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14320                         (unsigned int) (device_global_mem   / 1024 / 1024),
14321                         (unsigned int)  device_processors);
14322             }
14323             else
14324             {
14325               log_info ("- Device #%u: %s, skipped",
14326                         device_id + 1,
14327                         device_name);
14328             }
14329           }
14330         }
14331
14332         // common driver check
14333
14334         if (device_param->skipped == 0)
14335         {
14336           if (device_type & CL_DEVICE_TYPE_GPU)
14337           {
14338             if (platform_vendor_id == VENDOR_ID_AMD)
14339             {
14340               int catalyst_check = (force == 1) ? 0 : 1;
14341
14342               int catalyst_warn = 0;
14343
14344               int catalyst_broken = 0;
14345
14346               if (catalyst_check == 1)
14347               {
14348                 catalyst_warn = 1;
14349
14350                 // v14.9 and higher
14351                 if (atoi (device_param->driver_version) >= 1573)
14352                 {
14353                   catalyst_warn = 0;
14354                 }
14355
14356                 catalyst_check = 0;
14357               }
14358
14359               if (catalyst_broken == 1)
14360               {
14361                 log_info ("");
14362                 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14363                 log_info ("It passes over cracked hashes and will not report them as cracked");
14364                 log_info ("You are STRONGLY encouraged not to use it");
14365                 log_info ("You can use --force to override this but do not post error reports if you do so");
14366                 log_info ("");
14367
14368                 return (-1);
14369               }
14370
14371               if (catalyst_warn == 1)
14372               {
14373                 log_info ("");
14374                 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14375                 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14376                 log_info ("See hashcat's homepage for official supported catalyst drivers");
14377                 #ifdef _WIN
14378                 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14379                 #endif
14380                 log_info ("You can use --force to override this but do not post error reports if you do so");
14381                 log_info ("");
14382
14383                 return (-1);
14384               }
14385             }
14386             else if (platform_vendor_id == VENDOR_ID_NV)
14387             {
14388               if (device_param->kernel_exec_timeout != 0)
14389               {
14390                 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);
14391                 if (data.quiet == 0) log_info ("             See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14392               }
14393             }
14394           }
14395
14396           /* turns out pocl still creates segfaults (because of llvm)
14397           if (device_type & CL_DEVICE_TYPE_CPU)
14398           {
14399             if (platform_vendor_id == VENDOR_ID_AMD)
14400             {
14401               if (force == 0)
14402               {
14403                 log_info ("");
14404                 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14405                 log_info ("You are STRONGLY encouraged not to use it");
14406                 log_info ("You can use --force to override this but do not post error reports if you do so");
14407                 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14408                 log_info ("");
14409
14410                 return (-1);
14411               }
14412             }
14413           }
14414           */
14415
14416           /**
14417            * kernel accel and loops tuning db adjustment
14418            */
14419
14420           device_param->kernel_accel_min = 1;
14421           device_param->kernel_accel_max = 1024;
14422
14423           device_param->kernel_loops_min = 1;
14424           device_param->kernel_loops_max = 1024;
14425
14426           tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14427
14428           if (tuningdb_entry)
14429           {
14430             u32 _kernel_accel = tuningdb_entry->kernel_accel;
14431             u32 _kernel_loops = tuningdb_entry->kernel_loops;
14432
14433             if (_kernel_accel)
14434             {
14435               device_param->kernel_accel_min = _kernel_accel;
14436               device_param->kernel_accel_max = _kernel_accel;
14437             }
14438
14439             if (_kernel_loops)
14440             {
14441               if (workload_profile == 1)
14442               {
14443                 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14444               }
14445               else if (workload_profile == 2)
14446               {
14447                 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14448               }
14449
14450               device_param->kernel_loops_min = _kernel_loops;
14451               device_param->kernel_loops_max = _kernel_loops;
14452             }
14453           }
14454
14455           // commandline parameters overwrite tuningdb entries
14456
14457           if (kernel_accel)
14458           {
14459             device_param->kernel_accel_min = kernel_accel;
14460             device_param->kernel_accel_max = kernel_accel;
14461           }
14462
14463           if (kernel_loops)
14464           {
14465             device_param->kernel_loops_min = kernel_loops;
14466             device_param->kernel_loops_max = kernel_loops;
14467           }
14468
14469           /**
14470            * activate device
14471            */
14472
14473           devices_active++;
14474         }
14475
14476         // next please
14477
14478         devices_cnt++;
14479       }
14480
14481       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14482       {
14483         if (machine_readable == 0)
14484         {
14485           log_info ("");
14486         }
14487       }
14488     }
14489
14490     if (keyspace == 0 && devices_active == 0)
14491     {
14492       log_error ("ERROR: No devices found/left");
14493
14494       return (-1);
14495     }
14496
14497     // 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)
14498
14499     if (devices_filter != (uint) -1)
14500     {
14501       uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14502
14503       if (devices_filter > devices_cnt_mask)
14504       {
14505         log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14506
14507         return (-1);
14508       }
14509     }
14510
14511     data.devices_cnt = devices_cnt;
14512
14513     data.devices_active = devices_active;
14514
14515     /**
14516      * HM devices: init
14517      */
14518
14519     #ifdef HAVE_HWMON
14520     hm_attrs_t hm_adapters_adl[DEVICES_MAX]     = { { 0 } };
14521     hm_attrs_t hm_adapters_nvapi[DEVICES_MAX]   = { { 0 } };
14522     hm_attrs_t hm_adapters_nvml[DEVICES_MAX]    = { { 0 } };
14523     hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14524
14525     if (gpu_temp_disable == 0)
14526     {
14527       ADL_PTR     *adl     = (ADL_PTR *)     mymalloc (sizeof (ADL_PTR));
14528       NVAPI_PTR   *nvapi   = (NVAPI_PTR *)   mymalloc (sizeof (NVAPI_PTR));
14529       NVML_PTR    *nvml    = (NVML_PTR *)    mymalloc (sizeof (NVML_PTR));
14530       XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14531
14532       data.hm_adl     = NULL;
14533       data.hm_nvapi   = NULL;
14534       data.hm_nvml    = NULL;
14535       data.hm_xnvctrl = NULL;
14536
14537       if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14538       {
14539         data.hm_nvml = nvml;
14540       }
14541
14542       if (data.hm_nvml)
14543       {
14544         if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14545         {
14546           HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14547
14548           int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14549
14550           int tmp_out = 0;
14551
14552           for (int i = 0; i < tmp_in; i++)
14553           {
14554             hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14555           }
14556
14557           for (int i = 0; i < tmp_out; i++)
14558           {
14559             unsigned int speed;
14560
14561             if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14562
14563             // doesn't seem to create any advantages
14564             //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14565             //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14566           }
14567         }
14568       }
14569
14570       if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14571       {
14572         data.hm_nvapi = nvapi;
14573       }
14574
14575       if (data.hm_nvapi)
14576       {
14577         if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14578         {
14579           HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14580
14581           int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14582
14583           int tmp_out = 0;
14584
14585           for (int i = 0; i < tmp_in; i++)
14586           {
14587             hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14588           }
14589         }
14590       }
14591
14592       if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14593       {
14594         data.hm_xnvctrl = xnvctrl;
14595       }
14596
14597       if (data.hm_xnvctrl)
14598       {
14599         if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14600         {
14601           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14602           {
14603             hc_device_param_t *device_param = &data.devices_param[device_id];
14604
14605             if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14606
14607             hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14608
14609             int speed = 0;
14610
14611             if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14612           }
14613         }
14614       }
14615
14616       if ((need_adl == 1) && (adl_init (adl) == 0))
14617       {
14618         data.hm_adl = adl;
14619       }
14620
14621       if (data.hm_adl)
14622       {
14623         if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14624         {
14625           // total number of adapters
14626
14627           int hm_adapters_num;
14628
14629           if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14630
14631           // adapter info
14632
14633           LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14634
14635           if (lpAdapterInfo == NULL) return (-1);
14636
14637           // get a list (of ids of) valid/usable adapters
14638
14639           int num_adl_adapters = 0;
14640
14641           u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14642
14643           if (num_adl_adapters > 0)
14644           {
14645             hc_thread_mutex_lock (mux_adl);
14646
14647             // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14648
14649             hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14650
14651             hm_get_overdrive_version  (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14652             hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14653
14654             hc_thread_mutex_unlock (mux_adl);
14655           }
14656
14657           myfree (valid_adl_device_list);
14658           myfree (lpAdapterInfo);
14659         }
14660       }
14661
14662       if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14663       {
14664         gpu_temp_disable = 1;
14665       }
14666     }
14667
14668     /**
14669      * OpenCL devices: allocate buffer for device specific information
14670      */
14671
14672     ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14673
14674     int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14675
14676     unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14677
14678     /**
14679      * User-defined GPU temp handling
14680      */
14681
14682     if (gpu_temp_disable == 1)
14683     {
14684       gpu_temp_abort  = 0;
14685       gpu_temp_retain = 0;
14686     }
14687
14688     if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14689     {
14690       if (gpu_temp_abort < gpu_temp_retain)
14691       {
14692         log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14693
14694         return (-1);
14695       }
14696     }
14697
14698     data.gpu_temp_disable = gpu_temp_disable;
14699     data.gpu_temp_abort   = gpu_temp_abort;
14700     data.gpu_temp_retain  = gpu_temp_retain;
14701     #endif
14702
14703     /**
14704      * enable custom signal handler(s)
14705      */
14706
14707     if (benchmark == 0)
14708     {
14709       hc_signal (sigHandler_default);
14710     }
14711     else
14712     {
14713       hc_signal (sigHandler_benchmark);
14714     }
14715
14716     /**
14717      * inform the user
14718      */
14719
14720     if (data.quiet == 0)
14721     {
14722       log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14723
14724       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);
14725
14726       if (attack_mode == ATTACK_MODE_STRAIGHT)
14727       {
14728         log_info ("Rules: %u", kernel_rules_cnt);
14729       }
14730
14731       if (opti_type)
14732       {
14733         log_info ("Applicable Optimizers:");
14734
14735         for (uint i = 0; i < 32; i++)
14736         {
14737           const uint opti_bit = 1u << i;
14738
14739           if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14740         }
14741       }
14742
14743       /**
14744        * Watchdog and Temperature balance
14745        */
14746
14747       #ifdef HAVE_HWMON
14748       if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14749       {
14750         log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14751       }
14752
14753       if (gpu_temp_abort == 0)
14754       {
14755         log_info ("Watchdog: Temperature abort trigger disabled");
14756       }
14757       else
14758       {
14759         log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14760       }
14761
14762       if (gpu_temp_retain == 0)
14763       {
14764         log_info ("Watchdog: Temperature retain trigger disabled");
14765       }
14766       else
14767       {
14768         log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14769       }
14770
14771       if (data.quiet == 0) log_info ("");
14772       #endif
14773     }
14774
14775     #ifdef HAVE_HWMON
14776
14777     /**
14778      * HM devices: copy
14779      */
14780
14781     if (gpu_temp_disable == 0)
14782     {
14783       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14784       {
14785         hc_device_param_t *device_param = &data.devices_param[device_id];
14786
14787         if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14788
14789         if (device_param->skipped) continue;
14790
14791         const uint platform_devices_id = device_param->platform_devices_id;
14792
14793         if (device_param->device_vendor_id == VENDOR_ID_AMD)
14794         {
14795           data.hm_device[device_id].adl               = hm_adapters_adl[platform_devices_id].adl;
14796           data.hm_device[device_id].nvapi             = 0;
14797           data.hm_device[device_id].nvml              = 0;
14798           data.hm_device[device_id].xnvctrl           = 0;
14799           data.hm_device[device_id].od_version        = hm_adapters_adl[platform_devices_id].od_version;
14800           data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14801           data.hm_device[device_id].fan_set_supported = 0;
14802         }
14803
14804         if (device_param->device_vendor_id == VENDOR_ID_NV)
14805         {
14806           data.hm_device[device_id].adl               = 0;
14807           data.hm_device[device_id].nvapi             = hm_adapters_nvapi[platform_devices_id].nvapi;
14808           data.hm_device[device_id].nvml              = hm_adapters_nvml[platform_devices_id].nvml;
14809           data.hm_device[device_id].xnvctrl           = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14810           data.hm_device[device_id].od_version        = 0;
14811           data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14812           data.hm_device[device_id].fan_set_supported = 0;
14813         }
14814       }
14815     }
14816
14817     /**
14818      * powertune on user request
14819      */
14820
14821     if (powertune_enable == 1)
14822     {
14823       hc_thread_mutex_lock (mux_adl);
14824
14825       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14826       {
14827         hc_device_param_t *device_param = &data.devices_param[device_id];
14828
14829         if (device_param->skipped) continue;
14830
14831         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14832         {
14833           /**
14834            * Temporary fix:
14835            * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14836            * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14837            * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14838            * Driver / ADL bug?
14839            */
14840
14841           if (data.hm_device[device_id].od_version == 6)
14842           {
14843             int ADL_rc;
14844
14845             // check powertune capabilities first, if not available then skip device
14846
14847             int powertune_supported = 0;
14848
14849             if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14850             {
14851               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14852
14853               return (-1);
14854             }
14855
14856             // first backup current value, we will restore it later
14857
14858             if (powertune_supported != 0)
14859             {
14860               // powercontrol settings
14861
14862               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14863
14864               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14865               {
14866                 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14867               }
14868
14869               if (ADL_rc != ADL_OK)
14870               {
14871                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14872
14873                 return (-1);
14874               }
14875
14876               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14877               {
14878                 log_error ("ERROR: Failed to set new ADL PowerControl values");
14879
14880                 return (-1);
14881               }
14882
14883               // clocks
14884
14885               memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14886
14887               od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14888
14889               if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14890               {
14891                 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14892
14893                 return (-1);
14894               }
14895
14896               // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14897
14898               ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14899
14900               if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14901               {
14902                 log_error ("ERROR: Failed to get ADL device capabilities");
14903
14904                 return (-1);
14905               }
14906
14907               int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14908               int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14909
14910               int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14911               int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14912
14913               int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14914               int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14915
14916               // warning if profile has too low max values
14917
14918               if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14919               {
14920                 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14921               }
14922
14923               if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14924               {
14925                 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14926               }
14927
14928               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14929
14930               performance_state->iNumberOfPerformanceLevels = 2;
14931
14932               performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14933               performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14934               performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14935               performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14936
14937               if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14938               {
14939                 log_info ("ERROR: Failed to set ADL performance state");
14940
14941                 return (-1);
14942               }
14943
14944               local_free (performance_state);
14945             }
14946
14947             // set powertune value only
14948
14949             if (powertune_supported != 0)
14950             {
14951               // powertune set
14952               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14953
14954               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14955               {
14956                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14957
14958                 return (-1);
14959               }
14960
14961               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14962               {
14963                 log_error ("ERROR: Failed to set new ADL PowerControl values");
14964
14965                 return (-1);
14966               }
14967             }
14968           }
14969         }
14970
14971         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14972         {
14973           // first backup current value, we will restore it later
14974
14975           unsigned int limit;
14976
14977           int powertune_supported = 0;
14978
14979           if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14980           {
14981             powertune_supported = 1;
14982           }
14983
14984           // if backup worked, activate the maximum allowed
14985
14986           if (powertune_supported != 0)
14987           {
14988             unsigned int minLimit;
14989             unsigned int maxLimit;
14990
14991             if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14992             {
14993               if (maxLimit > 0)
14994               {
14995                 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14996                 {
14997                   // now we can be sure we need to reset later
14998
14999                   nvml_power_limit[device_id] = limit;
15000                 }
15001               }
15002             }
15003           }
15004         }
15005       }
15006
15007       hc_thread_mutex_unlock (mux_adl);
15008     }
15009
15010     #endif // HAVE_HWMON
15011
15012     #ifdef DEBUG
15013     if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15014     #endif
15015
15016     if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15017
15018     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15019     {
15020       /**
15021        * host buffer
15022        */
15023
15024       hc_device_param_t *device_param = &data.devices_param[device_id];
15025
15026       if (device_param->skipped) continue;
15027
15028       /**
15029        * device properties
15030        */
15031
15032       const char *device_name_chksum      = device_param->device_name_chksum;
15033       const u32   device_processors       = device_param->device_processors;
15034
15035       /**
15036        * create context for each device
15037        */
15038
15039       cl_context_properties properties[3];
15040
15041       properties[0] = CL_CONTEXT_PLATFORM;
15042       properties[1] = (cl_context_properties) device_param->platform;
15043       properties[2] = 0;
15044
15045       device_param->context = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL);
15046
15047       /**
15048        * create command-queue
15049        */
15050
15051       // not supported with NV
15052       // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15053
15054       device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15055
15056       /**
15057        * kernel threads: some algorithms need a fixed kernel-threads count
15058        *                 because of shared memory usage or bitslice
15059        *                 there needs to be some upper limit, otherwise there's too much overhead
15060        */
15061
15062       uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15063
15064       if (hash_mode ==  8900) kernel_threads = 64; // Scrypt
15065       if (hash_mode ==  9300) kernel_threads = 64; // Scrypt
15066
15067       if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15068       {
15069         kernel_threads = KERNEL_THREADS_MAX_CPU;
15070       }
15071
15072       if (hash_mode ==  1500) kernel_threads = 64; // DES
15073       if (hash_mode ==  3000) kernel_threads = 64; // DES
15074       if (hash_mode ==  3200) kernel_threads = 8;  // Blowfish
15075       if (hash_mode ==  7500) kernel_threads = 64; // RC4
15076       if (hash_mode ==  9000) kernel_threads = 8;  // Blowfish
15077       if (hash_mode ==  9700) kernel_threads = 64; // RC4
15078       if (hash_mode ==  9710) kernel_threads = 64; // RC4
15079       if (hash_mode ==  9800) kernel_threads = 64; // RC4
15080       if (hash_mode ==  9810) kernel_threads = 64; // RC4
15081       if (hash_mode == 10400) kernel_threads = 64; // RC4
15082       if (hash_mode == 10410) kernel_threads = 64; // RC4
15083       if (hash_mode == 10500) kernel_threads = 64; // RC4
15084       if (hash_mode == 13100) kernel_threads = 64; // RC4
15085
15086       device_param->kernel_threads = kernel_threads;
15087
15088       device_param->hardware_power = device_processors * kernel_threads;
15089
15090       /**
15091        * create input buffers on device : calculate size of fixed memory buffers
15092        */
15093
15094       size_t size_root_css   = SP_PW_MAX *           sizeof (cs_t);
15095       size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15096
15097       device_param->size_root_css   = size_root_css;
15098       device_param->size_markov_css = size_markov_css;
15099
15100       size_t size_results = sizeof (uint);
15101
15102       device_param->size_results = size_results;
15103
15104       size_t size_rules   = kernel_rules_cnt * sizeof (kernel_rule_t);
15105       size_t size_rules_c = KERNEL_RULES     * sizeof (kernel_rule_t);
15106
15107       size_t size_plains  = digests_cnt * sizeof (plain_t);
15108       size_t size_salts   = salts_cnt   * sizeof (salt_t);
15109       size_t size_esalts  = salts_cnt   * esalt_size;
15110
15111       device_param->size_plains   = size_plains;
15112       device_param->size_digests  = size_digests;
15113       device_param->size_shown    = size_shown;
15114       device_param->size_salts    = size_salts;
15115
15116       size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15117       size_t size_bfs   = KERNEL_BFS   * sizeof (bf_t);
15118       size_t size_tm    = 32           * sizeof (bs_word_t);
15119
15120       // scryptV stuff
15121
15122       size_t size_scrypt = 4;
15123
15124       if ((hash_mode == 8900) || (hash_mode == 9300))
15125       {
15126         // we need to check that all hashes have the same scrypt settings
15127
15128         const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15129         const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15130         const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15131
15132         for (uint i = 1; i < salts_cnt; i++)
15133         {
15134           if ((data.salts_buf[i].scrypt_N != scrypt_N)
15135            || (data.salts_buf[i].scrypt_r != scrypt_r)
15136            || (data.salts_buf[i].scrypt_p != scrypt_p))
15137           {
15138             log_error ("ERROR: Mixed scrypt settings not supported");
15139
15140             return -1;
15141           }
15142         }
15143
15144         uint tmto_start = 0;
15145         uint tmto_stop  = 10;
15146
15147         if (scrypt_tmto)
15148         {
15149           tmto_start = scrypt_tmto;
15150         }
15151         else
15152         {
15153           // in case the user did not specify the tmto manually
15154           // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15155
15156           if (hash_mode == 8900)
15157           {
15158             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15159             {
15160               tmto_start = 3;
15161             }
15162             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15163             {
15164               tmto_start = 2;
15165             }
15166           }
15167           else if (hash_mode == 9300)
15168           {
15169             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15170             {
15171               tmto_start = 2;
15172             }
15173             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15174             {
15175               tmto_start = 4;
15176             }
15177           }
15178         }
15179
15180         data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15181
15182         device_param->kernel_accel_min = 1;
15183         device_param->kernel_accel_max = 8;
15184
15185         uint tmto;
15186
15187         for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15188         {
15189           size_scrypt = (128 * scrypt_r) * scrypt_N;
15190
15191           size_scrypt /= 1 << tmto;
15192
15193           size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15194
15195           if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15196           {
15197             if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15198
15199             continue;
15200           }
15201
15202           if (size_scrypt > device_param->device_global_mem)
15203           {
15204             if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15205
15206             continue;
15207           }
15208
15209           for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15210           {
15211             data.scrypt_tmto_final = tmto;
15212           }
15213
15214           break;
15215         }
15216
15217         if (tmto == tmto_stop)
15218         {
15219           log_error ("ERROR: Can't allocate enough device memory");
15220
15221           return -1;
15222         }
15223
15224         if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15225       }
15226
15227       size_t size_scrypt4 = size_scrypt / 4;
15228
15229       /**
15230        * some algorithms need a fixed kernel-loops count
15231        */
15232
15233       if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15234       {
15235         const u32 kernel_loops_fixed = 1024;
15236
15237         device_param->kernel_loops_min = kernel_loops_fixed;
15238         device_param->kernel_loops_max = kernel_loops_fixed;
15239       }
15240
15241       if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15242       {
15243         const u32 kernel_loops_fixed = 1024;
15244
15245         device_param->kernel_loops_min = kernel_loops_fixed;
15246         device_param->kernel_loops_max = kernel_loops_fixed;
15247       }
15248
15249       if (hash_mode == 8900)
15250       {
15251         const u32 kernel_loops_fixed = 1;
15252
15253         device_param->kernel_loops_min = kernel_loops_fixed;
15254         device_param->kernel_loops_max = kernel_loops_fixed;
15255       }
15256
15257       if (hash_mode == 9300)
15258       {
15259         const u32 kernel_loops_fixed = 1;
15260
15261         device_param->kernel_loops_min = kernel_loops_fixed;
15262         device_param->kernel_loops_max = kernel_loops_fixed;
15263       }
15264
15265       if (hash_mode == 12500)
15266       {
15267         const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15268
15269         device_param->kernel_loops_min = kernel_loops_fixed;
15270         device_param->kernel_loops_max = kernel_loops_fixed;
15271       }
15272
15273       /**
15274        * some algorithms have a maximum kernel-loops count
15275        */
15276
15277       if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15278       {
15279         u32 innerloop_cnt = 0;
15280
15281         if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15282         {
15283           if      (data.attack_kern == ATTACK_KERN_STRAIGHT)  innerloop_cnt = data.kernel_rules_cnt;
15284           else if (data.attack_kern == ATTACK_KERN_COMBI)     innerloop_cnt = data.combs_cnt;
15285           else if (data.attack_kern == ATTACK_KERN_BF)        innerloop_cnt = data.bfs_cnt;
15286         }
15287         else
15288         {
15289           innerloop_cnt = data.salts_buf[0].salt_iter;
15290         }
15291
15292         if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15293             (innerloop_cnt <= device_param->kernel_loops_max))
15294         {
15295           device_param->kernel_loops_max = innerloop_cnt;
15296         }
15297       }
15298
15299       u32 kernel_accel_min = device_param->kernel_accel_min;
15300       u32 kernel_accel_max = device_param->kernel_accel_max;
15301
15302       // find out if we would request too much memory on memory blocks which are based on kernel_accel
15303
15304       size_t size_pws   = 4;
15305       size_t size_tmps  = 4;
15306       size_t size_hooks = 4;
15307
15308       while (kernel_accel_max >= kernel_accel_min)
15309       {
15310         const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15311
15312         // size_pws
15313
15314         size_pws = kernel_power_max * sizeof (pw_t);
15315
15316         // size_tmps
15317
15318         switch (hash_mode)
15319         {
15320           case   400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t);          break;
15321           case   500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15322           case   501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15323           case  1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15324           case  1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t);     break;
15325           case  2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t);            break;
15326           case  2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t);             break;
15327           case  3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t);          break;
15328           case  5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t);         break;
15329           case  5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t);      break;
15330           case  6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15331           case  6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15332           case  6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15333           case  6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15334           case  6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15335           case  6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15336           case  6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15337           case  6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15338           case  6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15339           case  6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15340           case  6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15341           case  6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15342           case  6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15343           case  6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t);       break;
15344           case  6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t);       break;
15345           case  6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t);        break;
15346           case  6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t);         break;
15347           case  6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t);        break;
15348           case  7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15349           case  7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15350           case  7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t);     break;
15351           case  7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t);         break;
15352           case  8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15353           case  8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t);      break;
15354           case  8900: size_tmps = kernel_power_max * data.scrypt_tmp_size;           break;
15355           case  9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t);         break;
15356           case  9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t);          break;
15357           case  9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15358           case  9300: size_tmps = kernel_power_max * data.scrypt_tmp_size;           break;
15359           case  9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t);      break;
15360           case  9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t);      break;
15361           case  9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t);      break;
15362           case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15363           case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t);            break;
15364           case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t);       break;
15365           case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t);           break;
15366           case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t);         break;
15367           case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15368           case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t);  break;
15369           case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t);       break;
15370           case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t);      break;
15371           case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15372           case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15373           case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t);        break;
15374           case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t);         break;
15375           case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t);       break;
15376           case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t);            break;
15377           case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t);        break;
15378           case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15379           case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15380           case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15381           case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t);         break;
15382           case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t);         break;
15383           case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15384           case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15385           case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15386           case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15387           case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15388           case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15389           case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15390           case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15391           case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15392           case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15393           case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15394           case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15395           case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15396           case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15397           case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15398           case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15399           case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15400           case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15401           case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15402         };
15403
15404         // size_hooks
15405
15406         if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15407         {
15408           switch (hash_mode)
15409           {
15410           }
15411         }
15412
15413         // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15414         // if not, decrease amplifier and try again
15415
15416         int memory_limit_hit = 0;
15417
15418         if (size_pws   > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15419         if (size_tmps  > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15420         if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15421
15422         const u64 size_total
15423           = bitmap_size
15424           + bitmap_size
15425           + bitmap_size
15426           + bitmap_size
15427           + bitmap_size
15428           + bitmap_size
15429           + bitmap_size
15430           + bitmap_size
15431           + size_bfs
15432           + size_combs
15433           + size_digests
15434           + size_esalts
15435           + size_hooks
15436           + size_markov_css
15437           + size_plains
15438           + size_pws
15439           + size_pws // not a bug
15440           + size_results
15441           + size_root_css
15442           + size_rules
15443           + size_rules_c
15444           + size_salts
15445           + size_scrypt4
15446           + size_scrypt4
15447           + size_scrypt4
15448           + size_scrypt4
15449           + size_shown
15450           + size_tm
15451           + size_tmps;
15452
15453         if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15454
15455         if (memory_limit_hit == 1)
15456         {
15457           kernel_accel_max--;
15458
15459           continue;
15460         }
15461
15462         break;
15463       }
15464
15465       if (kernel_accel_max < kernel_accel_min)
15466       {
15467         log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15468
15469         return -1;
15470       }
15471
15472       device_param->kernel_accel_min = kernel_accel_min;
15473       device_param->kernel_accel_max = kernel_accel_max;
15474
15475       /*
15476       if (kernel_accel_max < kernel_accel)
15477       {
15478         if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15479
15480         device_param->kernel_accel = kernel_accel_max;
15481       }
15482       */
15483
15484       device_param->size_bfs     = size_bfs;
15485       device_param->size_combs   = size_combs;
15486       device_param->size_rules   = size_rules;
15487       device_param->size_rules_c = size_rules_c;
15488       device_param->size_pws     = size_pws;
15489       device_param->size_tmps    = size_tmps;
15490       device_param->size_hooks   = size_hooks;
15491
15492       /**
15493        * default building options
15494        */
15495
15496       char cpath[1024] = { 0 };
15497
15498       char build_opts[1024] = { 0 };
15499
15500       #if _WIN
15501
15502       snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15503
15504       char *cpath_real = mymalloc (MAX_PATH);
15505
15506       if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15507       {
15508         log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15509
15510         return -1;
15511       }
15512
15513       naive_replace (cpath_real, '\\', '/');
15514
15515       // not escaping here, windows has quotes
15516
15517       snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15518
15519       #else
15520
15521       snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15522
15523       char *cpath_real = mymalloc (PATH_MAX);
15524
15525       if (realpath (cpath, cpath_real) == NULL)
15526       {
15527         log_error ("ERROR: %s: %s", cpath, strerror (errno));
15528
15529         return -1;
15530       }
15531
15532       naive_escape (cpath_real, PATH_MAX,  ' ', '\\');
15533
15534       snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15535
15536       #endif
15537
15538       // include check
15539       // this test needs to be done manually because of osx opencl runtime
15540       // if there's a problem with permission, its not reporting back and erroring out silently
15541
15542       #define files_cnt 15
15543
15544       const char *files_names[files_cnt] =
15545       {
15546         "inc_cipher_aes256.cl",
15547         "inc_cipher_serpent256.cl",
15548         "inc_cipher_twofish256.cl",
15549         "inc_common.cl",
15550         "inc_comp_multi_bs.cl",
15551         "inc_comp_multi.cl",
15552         "inc_comp_single_bs.cl",
15553         "inc_comp_single.cl",
15554         "inc_hash_constants.h",
15555         "inc_hash_functions.cl",
15556         "inc_rp.cl",
15557         "inc_rp.h",
15558         "inc_simd.cl",
15559         "inc_types.cl",
15560         "inc_vendor.cl",
15561       };
15562
15563       for (int i = 0; i < files_cnt; i++)
15564       {
15565         char path[1024] = { 0 };
15566
15567         snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15568
15569         FILE *fd = fopen (path, "r");
15570
15571         if (fd == NULL)
15572         {
15573           log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15574
15575           return -1;
15576         }
15577
15578         char buf[1];
15579
15580         size_t n = fread (buf, 1, 1, fd);
15581
15582         if (n != 1)
15583         {
15584           log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15585
15586           return -1;
15587         }
15588
15589         fclose (fd);
15590       }
15591
15592       myfree (cpath_real);
15593
15594       // we don't have sm_* on vendors not NV but it doesn't matter
15595
15596       char build_opts_new[1024] = { 0 };
15597
15598       snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_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, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
15599
15600       strncpy (build_opts, build_opts_new, sizeof (build_opts));
15601
15602       #ifdef DEBUG
15603       log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15604       #endif
15605
15606       /**
15607        * main kernel
15608        */
15609
15610       {
15611         /**
15612          * kernel source filename
15613          */
15614
15615         char source_file[256] = { 0 };
15616
15617         generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15618
15619         struct stat sst;
15620
15621         if (stat (source_file, &sst) == -1)
15622         {
15623           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15624
15625           return -1;
15626         }
15627
15628         /**
15629          * kernel cached filename
15630          */
15631
15632         char cached_file[256] = { 0 };
15633
15634         generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15635
15636         int cached = 1;
15637
15638         struct stat cst;
15639
15640         if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15641         {
15642           cached = 0;
15643         }
15644
15645         /**
15646          * kernel compile or load
15647          */
15648
15649         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15650
15651         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15652
15653         if (force_jit_compilation == -1)
15654         {
15655           if (cached == 0)
15656           {
15657             if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15658
15659             load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15660
15661             device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15662
15663             int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15664
15665             #ifdef DEBUG
15666             size_t build_log_size = 0;
15667
15668             hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15669
15670             if (build_log_size > 1)
15671             {
15672               char *build_log = (char *) malloc (build_log_size + 1);
15673
15674               memset (build_log, 0, build_log_size + 1);
15675
15676               hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15677
15678               puts (build_log);
15679
15680               free (build_log);
15681             }
15682             #endif
15683
15684             if (rc != 0)
15685             {
15686               device_param->skipped = true;
15687
15688               log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15689
15690               continue;
15691             }
15692
15693             size_t binary_size;
15694
15695             hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15696
15697             u8 *binary = (u8 *) mymalloc (binary_size);
15698
15699             hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15700
15701             writeProgramBin (cached_file, binary, binary_size);
15702
15703             local_free (binary);
15704           }
15705           else
15706           {
15707             #ifdef DEBUG
15708             log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15709             #endif
15710
15711             load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15712
15713             device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15714
15715             hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15716           }
15717         }
15718         else
15719         {
15720           #ifdef DEBUG
15721           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15722           #endif
15723
15724           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15725
15726           device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15727
15728           char build_opts_update[1024] = { 0 };
15729
15730           if (force_jit_compilation == 1500)
15731           {
15732             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15733           }
15734           else if (force_jit_compilation == 8900)
15735           {
15736             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
15737           }
15738           else
15739           {
15740             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15741           }
15742
15743           int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15744
15745           #ifdef DEBUG
15746           size_t build_log_size = 0;
15747
15748           hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15749
15750           if (build_log_size > 1)
15751           {
15752             char *build_log = (char *) malloc (build_log_size + 1);
15753
15754             memset (build_log, 0, build_log_size + 1);
15755
15756             hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15757
15758             puts (build_log);
15759
15760             free (build_log);
15761           }
15762           #endif
15763
15764           if (rc != 0)
15765           {
15766             device_param->skipped = true;
15767
15768             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15769           }
15770         }
15771
15772         local_free (kernel_lengths);
15773         local_free (kernel_sources[0]);
15774         local_free (kernel_sources);
15775       }
15776
15777       /**
15778        * word generator kernel
15779        */
15780
15781       if (attack_mode != ATTACK_MODE_STRAIGHT)
15782       {
15783         /**
15784          * kernel mp source filename
15785          */
15786
15787         char source_file[256] = { 0 };
15788
15789         generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15790
15791         struct stat sst;
15792
15793         if (stat (source_file, &sst) == -1)
15794         {
15795           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15796
15797           return -1;
15798         }
15799
15800         /**
15801          * kernel mp cached filename
15802          */
15803
15804         char cached_file[256] = { 0 };
15805
15806         generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15807
15808         int cached = 1;
15809
15810         struct stat cst;
15811
15812         if (stat (cached_file, &cst) == -1)
15813         {
15814           cached = 0;
15815         }
15816
15817         /**
15818          * kernel compile or load
15819          */
15820
15821         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15822
15823         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15824
15825         if (cached == 0)
15826         {
15827           if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15828           if (quiet == 0) log_info ("");
15829
15830           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15831
15832           device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15833
15834           int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15835
15836           if (rc != 0)
15837           {
15838             device_param->skipped = true;
15839
15840             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15841
15842             continue;
15843           }
15844
15845           size_t binary_size;
15846
15847           hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15848
15849           u8 *binary = (u8 *) mymalloc (binary_size);
15850
15851           hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15852
15853           writeProgramBin (cached_file, binary, binary_size);
15854
15855           local_free (binary);
15856         }
15857         else
15858         {
15859           #ifdef DEBUG
15860           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15861           #endif
15862
15863           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15864
15865           device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15866
15867           hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15868         }
15869
15870         local_free (kernel_lengths);
15871         local_free (kernel_sources[0]);
15872         local_free (kernel_sources);
15873       }
15874
15875       /**
15876        * amplifier kernel
15877        */
15878
15879       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15880       {
15881
15882       }
15883       else
15884       {
15885         /**
15886          * kernel amp source filename
15887          */
15888
15889         char source_file[256] = { 0 };
15890
15891         generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15892
15893         struct stat sst;
15894
15895         if (stat (source_file, &sst) == -1)
15896         {
15897           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15898
15899           return -1;
15900         }
15901
15902         /**
15903          * kernel amp cached filename
15904          */
15905
15906         char cached_file[256] = { 0 };
15907
15908         generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15909
15910         int cached = 1;
15911
15912         struct stat cst;
15913
15914         if (stat (cached_file, &cst) == -1)
15915         {
15916           cached = 0;
15917         }
15918
15919         /**
15920          * kernel compile or load
15921          */
15922
15923         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15924
15925         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15926
15927         if (cached == 0)
15928         {
15929           if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
15930           if (quiet == 0) log_info ("");
15931
15932           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15933
15934           device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15935
15936           int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15937
15938           if (rc != 0)
15939           {
15940             device_param->skipped = true;
15941
15942             log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15943
15944             continue;
15945           }
15946
15947           size_t binary_size;
15948
15949           hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15950
15951           u8 *binary = (u8 *) mymalloc (binary_size);
15952
15953           hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15954
15955           writeProgramBin (cached_file, binary, binary_size);
15956
15957           local_free (binary);
15958         }
15959         else
15960         {
15961           #ifdef DEBUG
15962           if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15963           #endif
15964
15965           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15966
15967           device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15968
15969           hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15970         }
15971
15972         local_free (kernel_lengths);
15973         local_free (kernel_sources[0]);
15974         local_free (kernel_sources);
15975       }
15976
15977       // some algorithm collide too fast, make that impossible
15978
15979       if (benchmark == 1)
15980       {
15981         ((uint *) digests_buf)[0] = -1;
15982         ((uint *) digests_buf)[1] = -1;
15983         ((uint *) digests_buf)[2] = -1;
15984         ((uint *) digests_buf)[3] = -1;
15985       }
15986
15987       /**
15988        * global buffers
15989        */
15990
15991       device_param->d_pws_buf       = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL);
15992       device_param->d_pws_amp_buf   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL);
15993       device_param->d_tmps          = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_tmps,    NULL);
15994       device_param->d_hooks         = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_hooks,   NULL);
15995       device_param->d_bitmap_s1_a   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15996       device_param->d_bitmap_s1_b   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15997       device_param->d_bitmap_s1_c   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15998       device_param->d_bitmap_s1_d   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15999       device_param->d_bitmap_s2_a   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
16000       device_param->d_bitmap_s2_b   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
16001       device_param->d_bitmap_s2_c   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
16002       device_param->d_bitmap_s2_d   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
16003       device_param->d_plain_bufs    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_plains,  NULL);
16004       device_param->d_digests_buf   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_digests, NULL);
16005       device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_shown,   NULL);
16006       device_param->d_salt_bufs     = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_salts,   NULL);
16007       device_param->d_result        = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_results, NULL);
16008       device_param->d_scryptV0_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL);
16009       device_param->d_scryptV1_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL);
16010       device_param->d_scryptV2_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL);
16011       device_param->d_scryptV3_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL);
16012
16013       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);
16014       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);
16015       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);
16016       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);
16017       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);
16018       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);
16019       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);
16020       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);
16021       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf,    CL_TRUE, 0, size_digests, data.digests_buf,   0, NULL, NULL);
16022       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown,  CL_TRUE, 0, size_shown,   data.digests_shown, 0, NULL, NULL);
16023       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs,      CL_TRUE, 0, size_salts,   data.salts_buf,     0, NULL, NULL);
16024
16025       /**
16026        * special buffers
16027        */
16028
16029       if (attack_kern == ATTACK_KERN_STRAIGHT)
16030       {
16031         device_param->d_rules   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules,   NULL);
16032         device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16033
16034         hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16035       }
16036       else if (attack_kern == ATTACK_KERN_COMBI)
16037       {
16038         device_param->d_combs           = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL);
16039         device_param->d_combs_c         = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL);
16040         device_param->d_root_css_buf    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL);
16041         device_param->d_markov_css_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16042       }
16043       else if (attack_kern == ATTACK_KERN_BF)
16044       {
16045         device_param->d_bfs             = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL);
16046         device_param->d_bfs_c           = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL);
16047         device_param->d_tm_c            = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm,         NULL);
16048         device_param->d_root_css_buf    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL);
16049         device_param->d_markov_css_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16050       }
16051
16052       if (size_esalts)
16053       {
16054         device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16055
16056         hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16057       }
16058
16059       /**
16060        * main host data
16061        */
16062
16063       pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16064
16065       device_param->pws_buf = pws_buf;
16066
16067       comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16068
16069       device_param->combs_buf = combs_buf;
16070
16071       void *hooks_buf = mymalloc (size_hooks);
16072
16073       device_param->hooks_buf = hooks_buf;
16074
16075       /**
16076        * kernel args
16077        */
16078
16079       device_param->kernel_params_buf32[24] = bitmap_mask;
16080       device_param->kernel_params_buf32[25] = bitmap_shift1;
16081       device_param->kernel_params_buf32[26] = bitmap_shift2;
16082       device_param->kernel_params_buf32[27] = 0; // salt_pos
16083       device_param->kernel_params_buf32[28] = 0; // loop_pos
16084       device_param->kernel_params_buf32[29] = 0; // loop_cnt
16085       device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16086       device_param->kernel_params_buf32[31] = 0; // digests_cnt
16087       device_param->kernel_params_buf32[32] = 0; // digests_offset
16088       device_param->kernel_params_buf32[33] = 0; // combs_mode
16089       device_param->kernel_params_buf32[34] = 0; // gid_max
16090
16091       device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16092                                       ? &device_param->d_pws_buf
16093                                       : &device_param->d_pws_amp_buf;
16094       device_param->kernel_params[ 1] = &device_param->d_rules_c;
16095       device_param->kernel_params[ 2] = &device_param->d_combs_c;
16096       device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16097       device_param->kernel_params[ 4] = &device_param->d_tmps;
16098       device_param->kernel_params[ 5] = &device_param->d_hooks;
16099       device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16100       device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16101       device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16102       device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16103       device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16104       device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16105       device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16106       device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16107       device_param->kernel_params[14] = &device_param->d_plain_bufs;
16108       device_param->kernel_params[15] = &device_param->d_digests_buf;
16109       device_param->kernel_params[16] = &device_param->d_digests_shown;
16110       device_param->kernel_params[17] = &device_param->d_salt_bufs;
16111       device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16112       device_param->kernel_params[19] = &device_param->d_result;
16113       device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16114       device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16115       device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16116       device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16117       device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16118       device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16119       device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16120       device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16121       device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16122       device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16123       device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16124       device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16125       device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16126       device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16127       device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16128
16129       device_param->kernel_params_mp_buf64[3] = 0;
16130       device_param->kernel_params_mp_buf32[4] = 0;
16131       device_param->kernel_params_mp_buf32[5] = 0;
16132       device_param->kernel_params_mp_buf32[6] = 0;
16133       device_param->kernel_params_mp_buf32[7] = 0;
16134       device_param->kernel_params_mp_buf32[8] = 0;
16135
16136       device_param->kernel_params_mp[0] = NULL;
16137       device_param->kernel_params_mp[1] = NULL;
16138       device_param->kernel_params_mp[2] = NULL;
16139       device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16140       device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16141       device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16142       device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16143       device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16144       device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16145
16146       device_param->kernel_params_mp_l_buf64[3] = 0;
16147       device_param->kernel_params_mp_l_buf32[4] = 0;
16148       device_param->kernel_params_mp_l_buf32[5] = 0;
16149       device_param->kernel_params_mp_l_buf32[6] = 0;
16150       device_param->kernel_params_mp_l_buf32[7] = 0;
16151       device_param->kernel_params_mp_l_buf32[8] = 0;
16152       device_param->kernel_params_mp_l_buf32[9] = 0;
16153
16154       device_param->kernel_params_mp_l[0] = NULL;
16155       device_param->kernel_params_mp_l[1] = NULL;
16156       device_param->kernel_params_mp_l[2] = NULL;
16157       device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16158       device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16159       device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16160       device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16161       device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16162       device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16163       device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16164
16165       device_param->kernel_params_mp_r_buf64[3] = 0;
16166       device_param->kernel_params_mp_r_buf32[4] = 0;
16167       device_param->kernel_params_mp_r_buf32[5] = 0;
16168       device_param->kernel_params_mp_r_buf32[6] = 0;
16169       device_param->kernel_params_mp_r_buf32[7] = 0;
16170       device_param->kernel_params_mp_r_buf32[8] = 0;
16171
16172       device_param->kernel_params_mp_r[0] = NULL;
16173       device_param->kernel_params_mp_r[1] = NULL;
16174       device_param->kernel_params_mp_r[2] = NULL;
16175       device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16176       device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16177       device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16178       device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16179       device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16180       device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16181
16182       device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16183       device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16184
16185       device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16186       device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16187       device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16188       device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16189       device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16190       device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16191       device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16192
16193       device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16194       device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16195
16196       device_param->kernel_params_memset_buf32[1] = 0; // value
16197       device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16198
16199       device_param->kernel_params_memset[0] = NULL;
16200       device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16201       device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16202
16203       /**
16204        * kernel name
16205        */
16206
16207       size_t kernel_wgs_tmp;
16208
16209       char kernel_name[64] = { 0 };
16210
16211       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16212       {
16213         if (opti_type & OPTI_TYPE_SINGLE_HASH)
16214         {
16215           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16216
16217           device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16218
16219           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16220
16221           device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16222
16223           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16224
16225           device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16226         }
16227         else
16228         {
16229           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16230
16231           device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16232
16233           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16234
16235           device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16236
16237           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16238
16239           device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16240         }
16241
16242         if (data.attack_mode == ATTACK_MODE_BF)
16243         {
16244           if (opts_type & OPTS_TYPE_PT_BITSLICE)
16245           {
16246             snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16247
16248             device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16249
16250             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);
16251           }
16252         }
16253       }
16254       else
16255       {
16256         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16257
16258         device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16259
16260         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16261
16262         device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16263
16264         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16265
16266         device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16267
16268         if (opts_type & OPTS_TYPE_HOOK12)
16269         {
16270           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16271
16272           device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16273
16274           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);
16275         }
16276
16277         if (opts_type & OPTS_TYPE_HOOK23)
16278         {
16279           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16280
16281           device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16282
16283           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);
16284         }
16285       }
16286
16287       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);
16288       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);
16289       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);
16290
16291       for (uint i = 0; i <= 23; i++)
16292       {
16293         hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16294         hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16295         hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16296
16297         if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16298         if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16299       }
16300
16301       for (uint i = 24; i <= 34; i++)
16302       {
16303         hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16304         hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16305         hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16306
16307         if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16308         if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16309       }
16310
16311       // GPU memset
16312
16313       device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16314
16315       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);
16316
16317       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem),  device_param->kernel_params_memset[0]);
16318       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16319       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16320
16321       // MP start
16322
16323       if (attack_mode == ATTACK_MODE_BF)
16324       {
16325         device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16326         device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16327
16328         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);
16329         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);
16330
16331         if (opts_type & OPTS_TYPE_PT_BITSLICE)
16332         {
16333           hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16334           hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16335         }
16336       }
16337       else if (attack_mode == ATTACK_MODE_HYBRID1)
16338       {
16339         device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16340
16341         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);
16342       }
16343       else if (attack_mode == ATTACK_MODE_HYBRID2)
16344       {
16345         device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16346
16347         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);
16348       }
16349
16350       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16351       {
16352         // nothing to do
16353       }
16354       else
16355       {
16356         device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16357
16358         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);
16359       }
16360
16361       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16362       {
16363         // nothing to do
16364       }
16365       else
16366       {
16367         for (uint i = 0; i < 5; i++)
16368         {
16369           hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16370         }
16371
16372         for (uint i = 5; i < 7; i++)
16373         {
16374           hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16375         }
16376       }
16377
16378       // maybe this has been updated by clGetKernelWorkGroupInfo()
16379       // value can only be decreased, so we don't need to reallocate buffers
16380
16381       device_param->kernel_threads = kernel_threads;
16382
16383       // zero some data buffers
16384
16385       run_kernel_bzero (device_param, device_param->d_pws_buf,        size_pws);
16386       run_kernel_bzero (device_param, device_param->d_pws_amp_buf,    size_pws);
16387       run_kernel_bzero (device_param, device_param->d_tmps,           size_tmps);
16388       run_kernel_bzero (device_param, device_param->d_hooks,          size_hooks);
16389       run_kernel_bzero (device_param, device_param->d_plain_bufs,     size_plains);
16390       run_kernel_bzero (device_param, device_param->d_result,         size_results);
16391
16392       /**
16393        * special buffers
16394        */
16395
16396       if (attack_kern == ATTACK_KERN_STRAIGHT)
16397       {
16398         run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16399       }
16400       else if (attack_kern == ATTACK_KERN_COMBI)
16401       {
16402         run_kernel_bzero (device_param, device_param->d_combs,          size_combs);
16403         run_kernel_bzero (device_param, device_param->d_combs_c,        size_combs);
16404         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
16405         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16406       }
16407       else if (attack_kern == ATTACK_KERN_BF)
16408       {
16409         run_kernel_bzero (device_param, device_param->d_bfs,            size_bfs);
16410         run_kernel_bzero (device_param, device_param->d_bfs_c,          size_bfs);
16411         run_kernel_bzero (device_param, device_param->d_tm_c,           size_tm);
16412         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
16413         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16414       }
16415
16416       #if defined(HAVE_HWMON)
16417
16418       /**
16419        * Store initial fanspeed if gpu_temp_retain is enabled
16420        */
16421
16422       if (gpu_temp_disable == 0)
16423       {
16424         if (gpu_temp_retain != 0)
16425         {
16426           hc_thread_mutex_lock (mux_adl);
16427
16428           if (data.hm_device[device_id].fan_get_supported == 1)
16429           {
16430             const int fanspeed  = hm_get_fanspeed_with_device_id  (device_id);
16431             const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16432
16433             // we also set it to tell the OS we take control over the fan and it's automatic controller
16434             // if it was set to automatic. we do not control user-defined fanspeeds.
16435
16436             if (fanpolicy == 1)
16437             {
16438               data.hm_device[device_id].fan_set_supported = 1;
16439
16440               int rc = -1;
16441
16442               if (device_param->device_vendor_id == VENDOR_ID_AMD)
16443               {
16444                 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16445               }
16446               else if (device_param->device_vendor_id == VENDOR_ID_NV)
16447               {
16448                 #ifdef LINUX
16449                 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16450                 #endif
16451
16452                 #ifdef WIN
16453                 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16454                 #endif
16455               }
16456
16457               if (rc == 0)
16458               {
16459                 data.hm_device[device_id].fan_set_supported = 1;
16460               }
16461               else
16462               {
16463                 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16464
16465                 data.hm_device[device_id].fan_set_supported = 0;
16466               }
16467             }
16468             else
16469             {
16470               data.hm_device[device_id].fan_set_supported = 0;
16471             }
16472           }
16473
16474           hc_thread_mutex_unlock (mux_adl);
16475         }
16476       }
16477
16478       #endif // HAVE_HWMON
16479     }
16480
16481     if (data.quiet == 0) log_info_nn ("");
16482
16483     /**
16484      * In benchmark-mode, inform user which algorithm is checked
16485      */
16486
16487     if (benchmark == 1)
16488     {
16489       if (machine_readable == 0)
16490       {
16491         quiet = 0;
16492
16493         data.quiet = quiet;
16494
16495         char *hash_type = strhashtype (data.hash_mode); // not a bug
16496
16497         log_info ("Hashtype: %s", hash_type);
16498         log_info ("");
16499       }
16500     }
16501
16502     /**
16503      * keep track of the progress
16504      */
16505
16506     data.words_progress_done     = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16507     data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16508     data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16509
16510     /**
16511      * open filehandles
16512      */
16513
16514     #if _WIN
16515     if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16516     {
16517       log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16518
16519       return (-1);
16520     }
16521
16522     if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16523     {
16524       log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16525
16526       return (-1);
16527     }
16528
16529     if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16530     {
16531       log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16532
16533       return (-1);
16534     }
16535     #endif
16536
16537     /**
16538      * dictionary pad
16539      */
16540
16541     segment_size *= (1024 * 1024);
16542
16543     data.segment_size = segment_size;
16544
16545     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16546
16547     wl_data->buf   = (char *) mymalloc (segment_size);
16548     wl_data->avail = segment_size;
16549     wl_data->incr  = segment_size;
16550     wl_data->cnt   = 0;
16551     wl_data->pos   = 0;
16552
16553     cs_t  *css_buf   = NULL;
16554     uint   css_cnt   = 0;
16555     uint   dictcnt   = 0;
16556     uint   maskcnt   = 1;
16557     char **masks     = NULL;
16558     char **dictfiles = NULL;
16559
16560     uint   mask_from_file = 0;
16561
16562     if (attack_mode == ATTACK_MODE_STRAIGHT)
16563     {
16564       if (wordlist_mode == WL_MODE_FILE)
16565       {
16566         int wls_left = myargc - (optind + 1);
16567
16568         for (int i = 0; i < wls_left; i++)
16569         {
16570           char *l0_filename = myargv[optind + 1 + i];
16571
16572           struct stat l0_stat;
16573
16574           if (stat (l0_filename, &l0_stat) == -1)
16575           {
16576             log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16577
16578             return (-1);
16579           }
16580
16581           uint is_dir = S_ISDIR (l0_stat.st_mode);
16582
16583           if (is_dir == 0)
16584           {
16585             dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16586
16587             dictcnt++;
16588
16589             dictfiles[dictcnt - 1] = l0_filename;
16590           }
16591           else
16592           {
16593             // do not allow --keyspace w/ a directory
16594
16595             if (keyspace == 1)
16596             {
16597               log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16598
16599               return (-1);
16600             }
16601
16602             char **dictionary_files = NULL;
16603
16604             dictionary_files = scan_directory (l0_filename);
16605
16606             if (dictionary_files != NULL)
16607             {
16608               qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16609
16610               for (int d = 0; dictionary_files[d] != NULL; d++)
16611               {
16612                 char *l1_filename = dictionary_files[d];
16613
16614                 struct stat l1_stat;
16615
16616                 if (stat (l1_filename, &l1_stat) == -1)
16617                 {
16618                   log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16619
16620                   return (-1);
16621                 }
16622
16623                 if (S_ISREG (l1_stat.st_mode))
16624                 {
16625                   dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16626
16627                   dictcnt++;
16628
16629                   dictfiles[dictcnt - 1] = strdup (l1_filename);
16630                 }
16631               }
16632             }
16633
16634             local_free (dictionary_files);
16635           }
16636         }
16637
16638         if (dictcnt < 1)
16639         {
16640           log_error ("ERROR: No usable dictionary file found.");
16641
16642           return (-1);
16643         }
16644       }
16645       else if (wordlist_mode == WL_MODE_STDIN)
16646       {
16647         dictcnt = 1;
16648       }
16649     }
16650     else if (attack_mode == ATTACK_MODE_COMBI)
16651     {
16652       // display
16653
16654       char *dictfile1 = myargv[optind + 1 + 0];
16655       char *dictfile2 = myargv[optind + 1 + 1];
16656
16657       // find the bigger dictionary and use as base
16658
16659       FILE *fp1 = NULL;
16660       FILE *fp2 = NULL;
16661
16662       struct stat tmp_stat;
16663
16664       if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16665       {
16666         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16667
16668         return (-1);
16669       }
16670
16671       if (stat (dictfile1, &tmp_stat) == -1)
16672       {
16673         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16674
16675         fclose (fp1);
16676
16677         return (-1);
16678       }
16679
16680       if (S_ISDIR (tmp_stat.st_mode))
16681       {
16682         log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16683
16684         fclose (fp1);
16685
16686         return (-1);
16687       }
16688
16689       if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16690       {
16691         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16692
16693         fclose (fp1);
16694
16695         return (-1);
16696       }
16697
16698       if (stat (dictfile2, &tmp_stat) == -1)
16699       {
16700         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16701
16702         fclose (fp1);
16703         fclose (fp2);
16704
16705         return (-1);
16706       }
16707
16708       if (S_ISDIR (tmp_stat.st_mode))
16709       {
16710         log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16711
16712         fclose (fp1);
16713         fclose (fp2);
16714
16715         return (-1);
16716       }
16717
16718       data.combs_cnt = 1;
16719
16720       data.quiet = 1;
16721
16722       const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16723
16724       data.quiet = quiet;
16725
16726       if (words1_cnt == 0)
16727       {
16728         log_error ("ERROR: %s: empty file", dictfile1);
16729
16730         fclose (fp1);
16731         fclose (fp2);
16732
16733         return (-1);
16734       }
16735
16736       data.combs_cnt = 1;
16737
16738       data.quiet = 1;
16739
16740       const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16741
16742       data.quiet = quiet;
16743
16744       if (words2_cnt == 0)
16745       {
16746         log_error ("ERROR: %s: empty file", dictfile2);
16747
16748         fclose (fp1);
16749         fclose (fp2);
16750
16751         return (-1);
16752       }
16753
16754       fclose (fp1);
16755       fclose (fp2);
16756
16757       data.dictfile  = dictfile1;
16758       data.dictfile2 = dictfile2;
16759
16760       if (words1_cnt >= words2_cnt)
16761       {
16762         data.combs_cnt  = words2_cnt;
16763         data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16764
16765         dictfiles = &data.dictfile;
16766
16767         dictcnt = 1;
16768       }
16769       else
16770       {
16771         data.combs_cnt  = words1_cnt;
16772         data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16773
16774         dictfiles = &data.dictfile2;
16775
16776         dictcnt = 1;
16777
16778         // we also have to switch wordlist related rules!
16779
16780         char *tmpc = data.rule_buf_l;
16781
16782         data.rule_buf_l = data.rule_buf_r;
16783         data.rule_buf_r = tmpc;
16784
16785         int   tmpi = data.rule_len_l;
16786
16787         data.rule_len_l = data.rule_len_r;
16788         data.rule_len_r = tmpi;
16789       }
16790     }
16791     else if (attack_mode == ATTACK_MODE_BF)
16792     {
16793       char *mask = NULL;
16794
16795       maskcnt = 0;
16796
16797       if (benchmark == 0)
16798       {
16799         mask = myargv[optind + 1];
16800
16801         masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16802
16803         if ((optind + 2) <= myargc)
16804         {
16805           struct stat file_stat;
16806
16807           if (stat (mask, &file_stat) == -1)
16808           {
16809             maskcnt = 1;
16810
16811             masks[maskcnt - 1] = mystrdup (mask);
16812           }
16813           else
16814           {
16815             int wls_left = myargc - (optind + 1);
16816
16817             uint masks_avail = INCR_MASKS;
16818
16819             for (int i = 0; i < wls_left; i++)
16820             {
16821               if (i != 0)
16822               {
16823                 mask = myargv[optind + 1 + i];
16824
16825                 if (stat (mask, &file_stat) == -1)
16826                 {
16827                   log_error ("ERROR: %s: %s", mask, strerror (errno));
16828
16829                   return (-1);
16830                 }
16831               }
16832
16833               uint is_file = S_ISREG (file_stat.st_mode);
16834
16835               if (is_file == 1)
16836               {
16837                 FILE *mask_fp;
16838
16839                 if ((mask_fp = fopen (mask, "r")) == NULL)
16840                 {
16841                   log_error ("ERROR: %s: %s", mask, strerror (errno));
16842
16843                   return (-1);
16844                 }
16845
16846                 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16847
16848                 while (!feof (mask_fp))
16849                 {
16850                   memset (line_buf, 0, HCBUFSIZ);
16851
16852                   int line_len = fgetl (mask_fp, line_buf);
16853
16854                   if (line_len == 0) continue;
16855
16856                   if (line_buf[0] == '#') continue;
16857
16858                   if (masks_avail == maskcnt)
16859                   {
16860                     masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16861
16862                     masks_avail += INCR_MASKS;
16863                   }
16864
16865                   masks[maskcnt] = mystrdup (line_buf);
16866
16867                   maskcnt++;
16868                 }
16869
16870                 myfree (line_buf);
16871
16872                 fclose (mask_fp);
16873               }
16874               else
16875               {
16876                 log_error ("ERROR: %s: unsupported file-type", mask);
16877
16878                 return (-1);
16879               }
16880             }
16881
16882             mask_from_file = 1;
16883           }
16884         }
16885         else
16886         {
16887           custom_charset_1 = (char *) "?l?d?u";
16888           custom_charset_2 = (char *) "?l?d";
16889           custom_charset_3 = (char *) "?l?d*!$@_";
16890
16891           mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16892           mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16893           mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16894
16895           masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16896
16897           wordlist_mode = WL_MODE_MASK;
16898
16899           data.wordlist_mode = wordlist_mode;
16900
16901           increment = 1;
16902
16903           maskcnt   = 1;
16904         }
16905       }
16906       else
16907       {
16908         /**
16909          * generate full masks and charsets
16910          */
16911
16912         masks = (char **) mymalloc (sizeof (char *));
16913
16914         switch (hash_mode)
16915         {
16916           case  1731: pw_min = 5;
16917                       pw_max = 5;
16918                       mask = mystrdup ("?b?b?b?b?b");
16919                       break;
16920           case 12500: pw_min = 5;
16921                       pw_max = 5;
16922                       mask = mystrdup ("?b?b?b?b?b");
16923                       break;
16924           default:    pw_min = 7;
16925                       pw_max = 7;
16926                       mask = mystrdup ("?b?b?b?b?b?b?b");
16927                       break;
16928         }
16929
16930         maskcnt = 1;
16931
16932         masks[maskcnt - 1] = mystrdup (mask);
16933
16934         wordlist_mode = WL_MODE_MASK;
16935
16936         data.wordlist_mode = wordlist_mode;
16937
16938         increment = 1;
16939       }
16940
16941       dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16942
16943       if (increment)
16944       {
16945         if (increment_min > pw_min) pw_min = increment_min;
16946
16947         if (increment_max < pw_max) pw_max = increment_max;
16948       }
16949     }
16950     else if (attack_mode == ATTACK_MODE_HYBRID1)
16951     {
16952       data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16953
16954       // display
16955
16956       char *mask = myargv[myargc - 1];
16957
16958       maskcnt = 0;
16959
16960       masks = (char **) mymalloc (1 * sizeof (char *));
16961
16962       // mod
16963
16964       struct stat file_stat;
16965
16966       if (stat (mask, &file_stat) == -1)
16967       {
16968         maskcnt = 1;
16969
16970         masks[maskcnt - 1] = mystrdup (mask);
16971       }
16972       else
16973       {
16974         uint is_file = S_ISREG (file_stat.st_mode);
16975
16976         if (is_file == 1)
16977         {
16978           FILE *mask_fp;
16979
16980           if ((mask_fp = fopen (mask, "r")) == NULL)
16981           {
16982             log_error ("ERROR: %s: %s", mask, strerror (errno));
16983
16984             return (-1);
16985           }
16986
16987           char *line_buf = (char *) mymalloc (HCBUFSIZ);
16988
16989           uint masks_avail = 1;
16990
16991           while (!feof (mask_fp))
16992           {
16993             memset (line_buf, 0, HCBUFSIZ);
16994
16995             int line_len = fgetl (mask_fp, line_buf);
16996
16997             if (line_len == 0) continue;
16998
16999             if (line_buf[0] == '#') continue;
17000
17001             if (masks_avail == maskcnt)
17002             {
17003               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17004
17005               masks_avail += INCR_MASKS;
17006             }
17007
17008             masks[maskcnt] = mystrdup (line_buf);
17009
17010             maskcnt++;
17011           }
17012
17013           myfree (line_buf);
17014
17015           fclose (mask_fp);
17016
17017           mask_from_file = 1;
17018         }
17019         else
17020         {
17021           maskcnt = 1;
17022
17023           masks[maskcnt - 1] = mystrdup (mask);
17024         }
17025       }
17026
17027       // base
17028
17029       int wls_left = myargc - (optind + 2);
17030
17031       for (int i = 0; i < wls_left; i++)
17032       {
17033         char *filename = myargv[optind + 1 + i];
17034
17035         struct stat file_stat;
17036
17037         if (stat (filename, &file_stat) == -1)
17038         {
17039           log_error ("ERROR: %s: %s", filename, strerror (errno));
17040
17041           return (-1);
17042         }
17043
17044         uint is_dir = S_ISDIR (file_stat.st_mode);
17045
17046         if (is_dir == 0)
17047         {
17048           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17049
17050           dictcnt++;
17051
17052           dictfiles[dictcnt - 1] = filename;
17053         }
17054         else
17055         {
17056           // do not allow --keyspace w/ a directory
17057
17058           if (keyspace == 1)
17059           {
17060             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17061
17062             return (-1);
17063           }
17064
17065           char **dictionary_files = NULL;
17066
17067           dictionary_files = scan_directory (filename);
17068
17069           if (dictionary_files != NULL)
17070           {
17071             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17072
17073             for (int d = 0; dictionary_files[d] != NULL; d++)
17074             {
17075               char *l1_filename = dictionary_files[d];
17076
17077               struct stat l1_stat;
17078
17079               if (stat (l1_filename, &l1_stat) == -1)
17080               {
17081                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17082
17083                 return (-1);
17084               }
17085
17086               if (S_ISREG (l1_stat.st_mode))
17087               {
17088                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17089
17090                 dictcnt++;
17091
17092                 dictfiles[dictcnt - 1] = strdup (l1_filename);
17093               }
17094             }
17095           }
17096
17097           local_free (dictionary_files);
17098         }
17099       }
17100
17101       if (dictcnt < 1)
17102       {
17103         log_error ("ERROR: No usable dictionary file found.");
17104
17105         return (-1);
17106       }
17107
17108       if (increment)
17109       {
17110         maskcnt = 0;
17111
17112         uint mask_min = increment_min; // we can't reject smaller masks here
17113         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17114
17115         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17116         {
17117           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17118
17119           if (cur_mask == NULL) break;
17120
17121           masks[maskcnt] = cur_mask;
17122
17123           maskcnt++;
17124
17125           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17126         }
17127       }
17128     }
17129     else if (attack_mode == ATTACK_MODE_HYBRID2)
17130     {
17131       data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17132
17133       // display
17134
17135       char *mask = myargv[optind + 1 + 0];
17136
17137       maskcnt = 0;
17138
17139       masks = (char **) mymalloc (1 * sizeof (char *));
17140
17141       // mod
17142
17143       struct stat file_stat;
17144
17145       if (stat (mask, &file_stat) == -1)
17146       {
17147         maskcnt = 1;
17148
17149         masks[maskcnt - 1] = mystrdup (mask);
17150       }
17151       else
17152       {
17153         uint is_file = S_ISREG (file_stat.st_mode);
17154
17155         if (is_file == 1)
17156         {
17157           FILE *mask_fp;
17158
17159           if ((mask_fp = fopen (mask, "r")) == NULL)
17160           {
17161             log_error ("ERROR: %s: %s", mask, strerror (errno));
17162
17163             return (-1);
17164           }
17165
17166           char *line_buf = (char *) mymalloc (HCBUFSIZ);
17167
17168           uint masks_avail = 1;
17169
17170           while (!feof (mask_fp))
17171           {
17172             memset (line_buf, 0, HCBUFSIZ);
17173
17174             int line_len = fgetl (mask_fp, line_buf);
17175
17176             if (line_len == 0) continue;
17177
17178             if (line_buf[0] == '#') continue;
17179
17180             if (masks_avail == maskcnt)
17181             {
17182               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17183
17184               masks_avail += INCR_MASKS;
17185             }
17186
17187             masks[maskcnt] = mystrdup (line_buf);
17188
17189             maskcnt++;
17190           }
17191
17192           myfree (line_buf);
17193
17194           fclose (mask_fp);
17195
17196           mask_from_file = 1;
17197         }
17198         else
17199         {
17200           maskcnt = 1;
17201
17202           masks[maskcnt - 1] = mystrdup (mask);
17203         }
17204       }
17205
17206       // base
17207
17208       int wls_left = myargc - (optind + 2);
17209
17210       for (int i = 0; i < wls_left; i++)
17211       {
17212         char *filename = myargv[optind + 2 + i];
17213
17214         struct stat file_stat;
17215
17216         if (stat (filename, &file_stat) == -1)
17217         {
17218           log_error ("ERROR: %s: %s", filename, strerror (errno));
17219
17220           return (-1);
17221         }
17222
17223         uint is_dir = S_ISDIR (file_stat.st_mode);
17224
17225         if (is_dir == 0)
17226         {
17227           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17228
17229           dictcnt++;
17230
17231           dictfiles[dictcnt - 1] = filename;
17232         }
17233         else
17234         {
17235           // do not allow --keyspace w/ a directory
17236
17237           if (keyspace == 1)
17238           {
17239             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17240
17241             return (-1);
17242           }
17243
17244           char **dictionary_files = NULL;
17245
17246           dictionary_files = scan_directory (filename);
17247
17248           if (dictionary_files != NULL)
17249           {
17250             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17251
17252             for (int d = 0; dictionary_files[d] != NULL; d++)
17253             {
17254               char *l1_filename = dictionary_files[d];
17255
17256               struct stat l1_stat;
17257
17258               if (stat (l1_filename, &l1_stat) == -1)
17259               {
17260                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17261
17262                 return (-1);
17263               }
17264
17265               if (S_ISREG (l1_stat.st_mode))
17266               {
17267                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17268
17269                 dictcnt++;
17270
17271                 dictfiles[dictcnt - 1] = strdup (l1_filename);
17272               }
17273             }
17274           }
17275
17276           local_free (dictionary_files);
17277         }
17278       }
17279
17280       if (dictcnt < 1)
17281       {
17282         log_error ("ERROR: No usable dictionary file found.");
17283
17284         return (-1);
17285       }
17286
17287       if (increment)
17288       {
17289         maskcnt = 0;
17290
17291         uint mask_min = increment_min; // we can't reject smaller masks here
17292         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17293
17294         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17295         {
17296           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17297
17298           if (cur_mask == NULL) break;
17299
17300           masks[maskcnt] = cur_mask;
17301
17302           maskcnt++;
17303
17304           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17305         }
17306       }
17307     }
17308
17309     data.pw_min = pw_min;
17310     data.pw_max = pw_max;
17311
17312     /**
17313      * weak hash check
17314      */
17315
17316     if (weak_hash_threshold >= salts_cnt)
17317     {
17318       hc_device_param_t *device_param = NULL;
17319
17320       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17321       {
17322         device_param = &data.devices_param[device_id];
17323
17324         if (device_param->skipped) continue;
17325
17326         break;
17327       }
17328
17329       if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17330
17331       for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17332       {
17333         weak_hash_check (device_param, salt_pos);
17334       }
17335
17336       // Display hack, guarantee that there is at least one \r before real start
17337
17338       //if (data.quiet == 0) log_info ("");
17339     }
17340
17341     /**
17342      * status and monitor threads
17343      */
17344
17345     if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17346     {
17347       data.devices_status = STATUS_STARTING;
17348     }
17349
17350     uint inner_threads_cnt = 0;
17351
17352     hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17353
17354     data.shutdown_inner = 0;
17355
17356     /**
17357       * Outfile remove
17358       */
17359
17360     if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17361     {
17362       hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17363
17364       inner_threads_cnt++;
17365
17366       if (outfile_check_timer != 0)
17367       {
17368         if (data.outfile_check_directory != NULL)
17369         {
17370           if ((hash_mode != 5200) &&
17371               !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
17372               !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17373               (hash_mode != 9000))
17374           {
17375             hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17376
17377             inner_threads_cnt++;
17378           }
17379           else
17380           {
17381             outfile_check_timer = 0;
17382           }
17383         }
17384         else
17385         {
17386           outfile_check_timer = 0;
17387         }
17388       }
17389     }
17390
17391     /**
17392      * Inform the user if we got some hashes remove because of the pot file remove feature
17393      */
17394
17395     if (data.quiet == 0)
17396     {
17397       if (potfile_remove_cracks > 0)
17398       {
17399         if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17400         else                            log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17401       }
17402     }
17403
17404     data.outfile_check_timer = outfile_check_timer;
17405
17406     /**
17407      * main loop
17408      */
17409
17410     char **induction_dictionaries = NULL;
17411
17412     int induction_dictionaries_cnt = 0;
17413
17414     hcstat_table_t *root_table_buf   = NULL;
17415     hcstat_table_t *markov_table_buf = NULL;
17416
17417     uint initial_restore_done = 0;
17418
17419     data.maskcnt = maskcnt;
17420
17421     for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17422     {
17423       if (data.devices_status == STATUS_CRACKED) continue;
17424       if (data.devices_status == STATUS_ABORTED) continue;
17425       if (data.devices_status == STATUS_QUIT)    continue;
17426
17427       if (maskpos > rd->maskpos)
17428       {
17429         rd->dictpos = 0;
17430       }
17431
17432       rd->maskpos  = maskpos;
17433       data.maskpos = maskpos;
17434
17435       if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17436       {
17437         char *mask = masks[maskpos];
17438
17439         if (mask_from_file == 1)
17440         {
17441           if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17442
17443           char *str_ptr;
17444           uint  str_pos;
17445
17446           uint mask_offset = 0;
17447
17448           uint separator_cnt;
17449
17450           for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17451           {
17452             str_ptr = strstr (mask + mask_offset, ",");
17453
17454             if (str_ptr == NULL) break;
17455
17456             str_pos = str_ptr - mask;
17457
17458             // escaped separator, i.e. "\,"
17459
17460             if (str_pos > 0)
17461             {
17462               if (mask[str_pos - 1] == '\\')
17463               {
17464                 separator_cnt --;
17465
17466                 mask_offset = str_pos + 1;
17467
17468                 continue;
17469               }
17470             }
17471
17472             // reset the offset
17473
17474             mask_offset = 0;
17475
17476             mask[str_pos] = '\0';
17477
17478             switch (separator_cnt)
17479             {
17480               case 0:
17481                 mp_reset_usr (mp_usr, 0);
17482
17483                 custom_charset_1 = mask;
17484                 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17485                 break;
17486
17487               case 1:
17488                 mp_reset_usr (mp_usr, 1);
17489
17490                 custom_charset_2 = mask;
17491                 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17492                 break;
17493
17494               case 2:
17495                 mp_reset_usr (mp_usr, 2);
17496
17497                 custom_charset_3 = mask;
17498                 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17499                 break;
17500
17501               case 3:
17502                 mp_reset_usr (mp_usr, 3);
17503
17504                 custom_charset_4 = mask;
17505                 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17506                 break;
17507             }
17508
17509             mask = mask + str_pos + 1;
17510           }
17511
17512           /**
17513            * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
17514            * it would be interpreted as a custom charset definition.
17515            *
17516            * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
17517            * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
17518            */
17519
17520           uint mask_len_cur = strlen (mask);
17521
17522           uint mask_out_pos = 0;
17523           char mask_prev = 0;
17524
17525           for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
17526           {
17527             if (mask[mask_iter] == ',')
17528             {
17529               if (mask_prev == '\\')
17530               {
17531                 mask_out_pos -= 1; // this means: skip the previous "\"
17532               }
17533             }
17534
17535             mask_prev = mask[mask_iter];
17536
17537             mask[mask_out_pos] = mask[mask_iter];
17538           }
17539
17540           mask[mask_out_pos] = '\0';
17541         }
17542
17543         if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17544         {
17545           if (maskpos > 0)
17546           {
17547             local_free (css_buf);
17548             local_free (data.root_css_buf);
17549             local_free (data.markov_css_buf);
17550
17551             local_free (masks[maskpos - 1]);
17552           }
17553
17554           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17555
17556           data.mask = mask;
17557           data.css_cnt = css_cnt;
17558           data.css_buf = css_buf;
17559
17560           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17561
17562           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17563
17564           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
17565           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17566
17567           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17568
17569           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17570
17571           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
17572           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17573
17574           data.root_css_buf   = root_css_buf;
17575           data.markov_css_buf = markov_css_buf;
17576
17577           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17578
17579           data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17580
17581           local_free (root_table_buf);
17582           local_free (markov_table_buf);
17583
17584           // args
17585
17586           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17587           {
17588             hc_device_param_t *device_param = &data.devices_param[device_id];
17589
17590             if (device_param->skipped) continue;
17591
17592             device_param->kernel_params_mp[0] = &device_param->d_combs;
17593             device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17594             device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17595
17596             device_param->kernel_params_mp_buf64[3] = 0;
17597             device_param->kernel_params_mp_buf32[4] = css_cnt;
17598             device_param->kernel_params_mp_buf32[5] = 0;
17599             device_param->kernel_params_mp_buf32[6] = 0;
17600             device_param->kernel_params_mp_buf32[7] = 0;
17601
17602             if (attack_mode == ATTACK_MODE_HYBRID1)
17603             {
17604               if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_buf32[5] = full01;
17605               if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_buf32[5] = full80;
17606               if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17607               if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17608             }
17609             else if (attack_mode == ATTACK_MODE_HYBRID2)
17610             {
17611               device_param->kernel_params_mp_buf32[5] = 0;
17612               device_param->kernel_params_mp_buf32[6] = 0;
17613               device_param->kernel_params_mp_buf32[7] = 0;
17614             }
17615
17616             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]);
17617             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]);
17618             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]);
17619
17620             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);
17621             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);
17622           }
17623         }
17624         else if (attack_mode == ATTACK_MODE_BF)
17625         {
17626           dictcnt = 0;  // number of "sub-masks", i.e. when using incremental mode
17627
17628           if (increment)
17629           {
17630             for (uint i = 0; i < dictcnt; i++)
17631             {
17632               local_free (dictfiles[i]);
17633             }
17634
17635             for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17636             {
17637               char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17638
17639               if (l1_filename == NULL) break;
17640
17641               dictcnt++;
17642
17643               dictfiles[dictcnt - 1] = l1_filename;
17644             }
17645           }
17646           else
17647           {
17648             dictcnt++;
17649
17650             dictfiles[dictcnt - 1] = mask;
17651           }
17652
17653           if (dictcnt == 0)
17654           {
17655             log_error ("ERROR: Mask is too small");
17656
17657             return (-1);
17658           }
17659         }
17660       }
17661
17662       free (induction_dictionaries);
17663
17664       // induction_dictionaries_cnt = 0; // implied
17665
17666       if (attack_mode != ATTACK_MODE_BF)
17667       {
17668         if (keyspace == 0)
17669         {
17670           induction_dictionaries = scan_directory (induction_directory);
17671
17672           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17673         }
17674       }
17675
17676       if (induction_dictionaries_cnt)
17677       {
17678         qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17679       }
17680
17681       /**
17682        * prevent the user from using --keyspace together w/ maskfile and or dictfile
17683        */
17684       if (keyspace == 1)
17685       {
17686         if ((maskcnt > 1) || (dictcnt > 1))
17687         {
17688           log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17689
17690           return (-1);
17691         }
17692       }
17693
17694       for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17695       {
17696         if (data.devices_status == STATUS_CRACKED) continue;
17697         if (data.devices_status == STATUS_ABORTED) continue;
17698         if (data.devices_status == STATUS_QUIT)    continue;
17699
17700         rd->dictpos = dictpos;
17701
17702         char *subid = logfile_generate_subid ();
17703
17704         data.subid = subid;
17705
17706         logfile_sub_msg ("START");
17707
17708         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17709         {
17710           data.devices_status = STATUS_INIT;
17711         }
17712
17713         memset (data.words_progress_done,     0, data.salts_cnt * sizeof (u64));
17714         memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17715         memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17716
17717         memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17718
17719         data.cpt_pos = 0;
17720
17721         data.cpt_start = time (NULL);
17722
17723         data.cpt_total = 0;
17724
17725         if (data.restore == 0)
17726         {
17727           rd->words_cur = skip;
17728
17729           skip = 0;
17730
17731           data.skip = 0;
17732         }
17733
17734         data.ms_paused = 0;
17735
17736         data.kernel_power_final = 0;
17737
17738         data.words_cur = rd->words_cur;
17739
17740         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17741         {
17742           hc_device_param_t *device_param = &data.devices_param[device_id];
17743
17744           if (device_param->skipped) continue;
17745
17746           device_param->speed_pos = 0;
17747
17748           memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17749           memset (device_param->speed_ms,  0, SPEED_CACHE * sizeof (double));
17750
17751           device_param->exec_pos = 0;
17752
17753           memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17754
17755           device_param->outerloop_pos  = 0;
17756           device_param->outerloop_left = 0;
17757           device_param->innerloop_pos  = 0;
17758           device_param->innerloop_left = 0;
17759
17760           // some more resets:
17761
17762           if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17763
17764           device_param->pws_cnt = 0;
17765
17766           device_param->words_off  = 0;
17767           device_param->words_done = 0;
17768         }
17769
17770         // figure out some workload
17771
17772         if (attack_mode == ATTACK_MODE_STRAIGHT)
17773         {
17774           if (data.wordlist_mode == WL_MODE_FILE)
17775           {
17776             char *dictfile = NULL;
17777
17778             if (induction_dictionaries_cnt)
17779             {
17780               dictfile = induction_dictionaries[0];
17781             }
17782             else
17783             {
17784               dictfile = dictfiles[dictpos];
17785             }
17786
17787             data.dictfile = dictfile;
17788
17789             logfile_sub_string (dictfile);
17790
17791             for (uint i = 0; i < rp_files_cnt; i++)
17792             {
17793               logfile_sub_var_string ("rulefile", rp_files[i]);
17794             }
17795
17796             FILE *fd2 = fopen (dictfile, "rb");
17797
17798             if (fd2 == NULL)
17799             {
17800               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17801
17802               return (-1);
17803             }
17804
17805             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17806
17807             fclose (fd2);
17808
17809             if (data.words_cnt == 0)
17810             {
17811               logfile_sub_msg ("STOP");
17812
17813               continue;
17814             }
17815           }
17816         }
17817         else if (attack_mode == ATTACK_MODE_COMBI)
17818         {
17819           char *dictfile  = data.dictfile;
17820           char *dictfile2 = data.dictfile2;
17821
17822           logfile_sub_string (dictfile);
17823           logfile_sub_string (dictfile2);
17824
17825           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17826           {
17827             FILE *fd2 = fopen (dictfile, "rb");
17828
17829             if (fd2 == NULL)
17830             {
17831               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17832
17833               return (-1);
17834             }
17835
17836             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17837
17838             fclose (fd2);
17839           }
17840           else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17841           {
17842             FILE *fd2 = fopen (dictfile2, "rb");
17843
17844             if (fd2 == NULL)
17845             {
17846               log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17847
17848               return (-1);
17849             }
17850
17851             data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17852
17853             fclose (fd2);
17854           }
17855
17856           if (data.words_cnt == 0)
17857           {
17858             logfile_sub_msg ("STOP");
17859
17860             continue;
17861           }
17862         }
17863         else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17864         {
17865           char *dictfile = NULL;
17866
17867           if (induction_dictionaries_cnt)
17868           {
17869             dictfile = induction_dictionaries[0];
17870           }
17871           else
17872           {
17873             dictfile = dictfiles[dictpos];
17874           }
17875
17876           data.dictfile = dictfile;
17877
17878           char *mask = data.mask;
17879
17880           logfile_sub_string (dictfile);
17881           logfile_sub_string (mask);
17882
17883           FILE *fd2 = fopen (dictfile, "rb");
17884
17885           if (fd2 == NULL)
17886           {
17887             log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17888
17889             return (-1);
17890           }
17891
17892           data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17893
17894           fclose (fd2);
17895
17896           if (data.words_cnt == 0)
17897           {
17898             logfile_sub_msg ("STOP");
17899
17900             continue;
17901           }
17902         }
17903         else if (attack_mode == ATTACK_MODE_BF)
17904         {
17905           local_free (css_buf);
17906           local_free (data.root_css_buf);
17907           local_free (data.markov_css_buf);
17908
17909           char *mask = dictfiles[dictpos];
17910
17911           logfile_sub_string (mask);
17912
17913           // base
17914
17915           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17916
17917           if (opts_type & OPTS_TYPE_PT_UNICODE)
17918           {
17919             uint css_cnt_unicode = css_cnt * 2;
17920
17921             cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17922
17923             for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17924             {
17925               memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17926
17927               css_buf_unicode[j + 1].cs_buf[0] = 0;
17928               css_buf_unicode[j + 1].cs_len    = 1;
17929             }
17930
17931             free (css_buf);
17932
17933             css_buf = css_buf_unicode;
17934             css_cnt = css_cnt_unicode;
17935           }
17936
17937           // check if mask is not too large or too small for pw_min/pw_max  (*2 if unicode)
17938
17939           uint mask_min = pw_min;
17940           uint mask_max = pw_max;
17941
17942           if (opts_type & OPTS_TYPE_PT_UNICODE)
17943           {
17944             mask_min *= 2;
17945             mask_max *= 2;
17946           }
17947
17948           if ((css_cnt < mask_min) || (css_cnt > mask_max))
17949           {
17950             if (css_cnt < mask_min)
17951             {
17952               log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17953             }
17954
17955             if (css_cnt > mask_max)
17956             {
17957               log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17958             }
17959
17960             // skip to next mask
17961
17962             logfile_sub_msg ("STOP");
17963
17964             continue;
17965           }
17966
17967           uint save_css_cnt = css_cnt;
17968
17969           if (opti_type & OPTI_TYPE_SINGLE_HASH)
17970           {
17971             if (opti_type & OPTI_TYPE_APPENDED_SALT)
17972             {
17973               uint  salt_len = (uint)   data.salts_buf[0].salt_len;
17974               char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17975
17976               uint css_cnt_salt = css_cnt + salt_len;
17977
17978               cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17979
17980               memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17981
17982               for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17983               {
17984                 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17985                 css_buf_salt[j].cs_len    = 1;
17986               }
17987
17988               free (css_buf);
17989
17990               css_buf = css_buf_salt;
17991               css_cnt = css_cnt_salt;
17992             }
17993           }
17994
17995           data.mask = mask;
17996           data.css_cnt = css_cnt;
17997           data.css_buf = css_buf;
17998
17999           if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
18000
18001           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18002
18003           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18004
18005           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
18006           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18007
18008           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18009
18010           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18011
18012           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
18013           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18014
18015           data.root_css_buf   = root_css_buf;
18016           data.markov_css_buf = markov_css_buf;
18017
18018           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18019
18020           data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18021
18022           local_free (root_table_buf);
18023           local_free (markov_table_buf);
18024
18025           // copy + args
18026
18027           uint css_cnt_l = css_cnt;
18028           uint css_cnt_r;
18029
18030           if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
18031           {
18032             if (save_css_cnt < 6)
18033             {
18034               css_cnt_r = 1;
18035             }
18036             else if (save_css_cnt == 6)
18037             {
18038               css_cnt_r = 2;
18039             }
18040             else
18041             {
18042               if (opts_type & OPTS_TYPE_PT_UNICODE)
18043               {
18044                 if (save_css_cnt == 8 || save_css_cnt == 10)
18045                 {
18046                   css_cnt_r = 2;
18047                 }
18048                 else
18049                 {
18050                   css_cnt_r = 4;
18051                 }
18052               }
18053               else
18054               {
18055                 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18056                 {
18057                   css_cnt_r = 3;
18058                 }
18059                 else
18060                 {
18061                   css_cnt_r = 4;
18062                 }
18063               }
18064             }
18065           }
18066           else
18067           {
18068             css_cnt_r = 1;
18069
18070             /* unfinished code?
18071             int sum = css_buf[css_cnt_r - 1].cs_len;
18072
18073             for (uint i = 1; i < 4 && i < css_cnt; i++)
18074             {
18075               if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18076
18077               css_cnt_r++;
18078
18079               sum *= css_buf[css_cnt_r - 1].cs_len;
18080             }
18081             */
18082           }
18083
18084           css_cnt_l -= css_cnt_r;
18085
18086           data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18087
18088           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18089           {
18090             hc_device_param_t *device_param = &data.devices_param[device_id];
18091
18092             if (device_param->skipped) continue;
18093
18094             device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18095             device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18096             device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18097
18098             device_param->kernel_params_mp_l_buf64[3] = 0;
18099             device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18100             device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18101             device_param->kernel_params_mp_l_buf32[6] = 0;
18102             device_param->kernel_params_mp_l_buf32[7] = 0;
18103             device_param->kernel_params_mp_l_buf32[8] = 0;
18104
18105             if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_l_buf32[6] = full01;
18106             if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_l_buf32[6] = full80;
18107             if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18108             if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18109
18110             device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18111             device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18112             device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18113
18114             device_param->kernel_params_mp_r_buf64[3] = 0;
18115             device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18116             device_param->kernel_params_mp_r_buf32[5] = 0;
18117             device_param->kernel_params_mp_r_buf32[6] = 0;
18118             device_param->kernel_params_mp_r_buf32[7] = 0;
18119
18120             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]);
18121             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]);
18122             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]);
18123
18124             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]);
18125             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]);
18126             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]);
18127
18128             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);
18129             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);
18130           }
18131         }
18132
18133         u64 words_base = data.words_cnt;
18134
18135         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18136         {
18137           if (data.kernel_rules_cnt)
18138           {
18139             words_base /= data.kernel_rules_cnt;
18140           }
18141         }
18142         else if (data.attack_kern == ATTACK_KERN_COMBI)
18143         {
18144           if (data.combs_cnt)
18145           {
18146             words_base /= data.combs_cnt;
18147           }
18148         }
18149         else if (data.attack_kern == ATTACK_KERN_BF)
18150         {
18151           if (data.bfs_cnt)
18152           {
18153             words_base /= data.bfs_cnt;
18154           }
18155         }
18156
18157         data.words_base = words_base;
18158
18159         if (keyspace == 1)
18160         {
18161           log_info ("%llu", (unsigned long long int) words_base);
18162
18163           return (0);
18164         }
18165
18166         if (data.words_cur > data.words_base)
18167         {
18168           log_error ("ERROR: Restore value greater keyspace");
18169
18170           return (-1);
18171         }
18172
18173         if (data.words_cur)
18174         {
18175           if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18176           {
18177             for (uint i = 0; i < data.salts_cnt; i++)
18178             {
18179               data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18180             }
18181           }
18182           else if (data.attack_kern == ATTACK_KERN_COMBI)
18183           {
18184             for (uint i = 0; i < data.salts_cnt; i++)
18185             {
18186               data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18187             }
18188           }
18189           else if (data.attack_kern == ATTACK_KERN_BF)
18190           {
18191             for (uint i = 0; i < data.salts_cnt; i++)
18192             {
18193               data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18194             }
18195           }
18196         }
18197
18198         /*
18199          * Update loopback file
18200          */
18201
18202         if (loopback == 1)
18203         {
18204           time_t now;
18205
18206           time (&now);
18207
18208           uint random_num = get_random_num (0, 9999);
18209
18210           snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18211
18212           data.loopback_file = loopback_file;
18213         }
18214
18215         /*
18216          * Update dictionary statistic
18217          */
18218
18219         if (keyspace == 0)
18220         {
18221           dictstat_fp = fopen (dictstat, "wb");
18222
18223           if (dictstat_fp)
18224           {
18225             lock_file (dictstat_fp);
18226
18227             fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18228
18229             fclose (dictstat_fp);
18230           }
18231         }
18232
18233         /**
18234          * create autotune threads
18235          */
18236
18237         hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18238
18239         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18240         {
18241           data.devices_status = STATUS_AUTOTUNE;
18242         }
18243
18244         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18245         {
18246           hc_device_param_t *device_param = &devices_param[device_id];
18247
18248           hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18249         }
18250
18251         hc_thread_wait (data.devices_cnt, c_threads);
18252
18253         /*
18254          * Inform user about possible slow speeds
18255          */
18256
18257         uint hardware_power_all = 0;
18258
18259         uint kernel_power_all = 0;
18260
18261         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18262         {
18263           hc_device_param_t *device_param = &devices_param[device_id];
18264
18265           hardware_power_all += device_param->hardware_power;
18266
18267           kernel_power_all += device_param->kernel_power;
18268         }
18269
18270         data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
18271
18272         data.kernel_power_all = kernel_power_all;
18273
18274         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18275         {
18276           if (data.words_base < kernel_power_all)
18277           {
18278             if (quiet == 0)
18279             {
18280               clear_prompt ();
18281
18282               log_info ("ATTENTION!");
18283               log_info ("  The wordlist or mask you are using is too small.");
18284               log_info ("  Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18285               log_info ("  The cracking speed will drop.");
18286               log_info ("  Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18287               log_info ("");
18288             }
18289           }
18290         }
18291
18292         /**
18293          * create cracker threads
18294          */
18295
18296         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18297         {
18298           data.devices_status = STATUS_RUNNING;
18299         }
18300
18301         if (initial_restore_done == 0)
18302         {
18303           if (data.restore_disable == 0) cycle_restore ();
18304
18305           initial_restore_done = 1;
18306         }
18307
18308         hc_timer_set (&data.timer_running);
18309
18310         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18311         {
18312           if ((quiet == 0) && (status == 0) && (benchmark == 0))
18313           {
18314             if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18315             if (quiet == 0) fflush (stdout);
18316           }
18317         }
18318         else if (wordlist_mode == WL_MODE_STDIN)
18319         {
18320           if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18321           if (data.quiet == 0) log_info ("");
18322         }
18323
18324         time_t runtime_start;
18325
18326         time (&runtime_start);
18327
18328         data.runtime_start = runtime_start;
18329
18330         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18331         {
18332           hc_device_param_t *device_param = &devices_param[device_id];
18333
18334           if (wordlist_mode == WL_MODE_STDIN)
18335           {
18336             hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18337           }
18338           else
18339           {
18340             hc_thread_create (c_threads[device_id], thread_calc, device_param);
18341           }
18342         }
18343
18344         hc_thread_wait (data.devices_cnt, c_threads);
18345
18346         local_free (c_threads);
18347
18348         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18349         {
18350           data.devices_status = STATUS_EXHAUSTED;
18351         }
18352
18353         logfile_sub_var_uint ("status-after-work", data.devices_status);
18354
18355         data.restore = 0;
18356
18357         if (induction_dictionaries_cnt)
18358         {
18359           unlink (induction_dictionaries[0]);
18360         }
18361
18362         free (induction_dictionaries);
18363
18364         if (attack_mode != ATTACK_MODE_BF)
18365         {
18366           induction_dictionaries = scan_directory (induction_directory);
18367
18368           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18369         }
18370
18371         if (benchmark == 1)
18372         {
18373           status_benchmark ();
18374
18375           if (machine_readable == 0)
18376           {
18377             log_info ("");
18378           }
18379         }
18380         else
18381         {
18382           if (quiet == 0)
18383           {
18384             clear_prompt ();
18385
18386             log_info ("");
18387
18388             status_display ();
18389
18390             log_info ("");
18391           }
18392           else
18393           {
18394             if (status == 1)
18395             {
18396               status_display ();
18397             }
18398           }
18399         }
18400
18401         if (induction_dictionaries_cnt)
18402         {
18403           qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18404
18405           // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
18406
18407           dictpos--;
18408         }
18409
18410         time_t runtime_stop;
18411
18412         time (&runtime_stop);
18413
18414         data.runtime_stop = runtime_stop;
18415
18416         logfile_sub_uint (runtime_start);
18417         logfile_sub_uint (runtime_stop);
18418
18419         logfile_sub_msg ("STOP");
18420
18421         global_free (subid);
18422
18423         // from this point we handle bypass as running
18424
18425         if (data.devices_status == STATUS_BYPASS)
18426         {
18427           data.devices_status = STATUS_RUNNING;
18428         }
18429
18430         // and overwrite benchmark aborts as well
18431
18432         if (data.benchmark == 1)
18433         {
18434           if (data.devices_status == STATUS_ABORTED)
18435           {
18436             data.devices_status = STATUS_RUNNING;
18437           }
18438         }
18439
18440         // finalize task
18441
18442         if (data.devices_status == STATUS_CRACKED) break;
18443         if (data.devices_status == STATUS_ABORTED) break;
18444         if (data.devices_status == STATUS_QUIT)    break;
18445       }
18446
18447       if (data.devices_status == STATUS_CRACKED) break;
18448       if (data.devices_status == STATUS_ABORTED) break;
18449       if (data.devices_status == STATUS_QUIT)    break;
18450     }
18451
18452     // 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
18453     if (attack_mode == ATTACK_MODE_STRAIGHT)
18454     {
18455       if (data.wordlist_mode == WL_MODE_FILE)
18456       {
18457         if (data.dictfile == NULL)
18458         {
18459           if (dictfiles != NULL)
18460           {
18461             data.dictfile = dictfiles[0];
18462
18463             hc_timer_set (&data.timer_running);
18464           }
18465         }
18466       }
18467     }
18468     // NOTE: combi is okay because it is already set beforehand
18469     else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18470     {
18471       if (data.dictfile == NULL)
18472       {
18473         if (dictfiles != NULL)
18474         {
18475           hc_timer_set (&data.timer_running);
18476
18477           data.dictfile = dictfiles[0];
18478         }
18479       }
18480     }
18481     else if (attack_mode == ATTACK_MODE_BF)
18482     {
18483       if (data.mask == NULL)
18484       {
18485         hc_timer_set (&data.timer_running);
18486
18487         data.mask = masks[0];
18488       }
18489     }
18490
18491     // if cracked / aborted remove last induction dictionary
18492
18493     for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18494     {
18495       struct stat induct_stat;
18496
18497       if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18498       {
18499         unlink (induction_dictionaries[file_pos]);
18500       }
18501     }
18502
18503     // wait for inner threads
18504
18505     data.shutdown_inner = 1;
18506
18507     for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18508     {
18509       hc_thread_wait (1, &inner_threads[thread_idx]);
18510     }
18511
18512     local_free (inner_threads);
18513
18514     // we dont need restore file anymore
18515     if (data.restore_disable == 0)
18516     {
18517       if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18518       {
18519         unlink (eff_restore_file);
18520         unlink (new_restore_file);
18521       }
18522       else
18523       {
18524         cycle_restore ();
18525       }
18526     }
18527
18528     // finally save left hashes
18529
18530     if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18531     {
18532       save_hash ();
18533     }
18534
18535     /**
18536      * Clean up
18537      */
18538
18539     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18540     {
18541       hc_device_param_t *device_param = &data.devices_param[device_id];
18542
18543       if (device_param->skipped) continue;
18544
18545       local_free (device_param->combs_buf);
18546       local_free (device_param->hooks_buf);
18547       local_free (device_param->device_name);
18548       local_free (device_param->device_name_chksum);
18549       local_free (device_param->device_version);
18550       local_free (device_param->driver_version);
18551
18552       if (device_param->pws_buf)            myfree                    (device_param->pws_buf);
18553       if (device_param->d_pws_buf)          hc_clReleaseMemObject     (data.ocl, device_param->d_pws_buf);
18554       if (device_param->d_pws_amp_buf)      hc_clReleaseMemObject     (data.ocl, device_param->d_pws_amp_buf);
18555       if (device_param->d_rules)            hc_clReleaseMemObject     (data.ocl, device_param->d_rules);
18556       if (device_param->d_rules_c)          hc_clReleaseMemObject     (data.ocl, device_param->d_rules_c);
18557       if (device_param->d_combs)            hc_clReleaseMemObject     (data.ocl, device_param->d_combs);
18558       if (device_param->d_combs_c)          hc_clReleaseMemObject     (data.ocl, device_param->d_combs_c);
18559       if (device_param->d_bfs)              hc_clReleaseMemObject     (data.ocl, device_param->d_bfs);
18560       if (device_param->d_bfs_c)            hc_clReleaseMemObject     (data.ocl, device_param->d_bfs_c);
18561       if (device_param->d_bitmap_s1_a)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_a);
18562       if (device_param->d_bitmap_s1_b)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_b);
18563       if (device_param->d_bitmap_s1_c)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_c);
18564       if (device_param->d_bitmap_s1_d)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_d);
18565       if (device_param->d_bitmap_s2_a)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_a);
18566       if (device_param->d_bitmap_s2_b)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_b);
18567       if (device_param->d_bitmap_s2_c)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_c);
18568       if (device_param->d_bitmap_s2_d)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_d);
18569       if (device_param->d_plain_bufs)       hc_clReleaseMemObject     (data.ocl, device_param->d_plain_bufs);
18570       if (device_param->d_digests_buf)      hc_clReleaseMemObject     (data.ocl, device_param->d_digests_buf);
18571       if (device_param->d_digests_shown)    hc_clReleaseMemObject     (data.ocl, device_param->d_digests_shown);
18572       if (device_param->d_salt_bufs)        hc_clReleaseMemObject     (data.ocl, device_param->d_salt_bufs);
18573       if (device_param->d_esalt_bufs)       hc_clReleaseMemObject     (data.ocl, device_param->d_esalt_bufs);
18574       if (device_param->d_tmps)             hc_clReleaseMemObject     (data.ocl, device_param->d_tmps);
18575       if (device_param->d_hooks)            hc_clReleaseMemObject     (data.ocl, device_param->d_hooks);
18576       if (device_param->d_result)           hc_clReleaseMemObject     (data.ocl, device_param->d_result);
18577       if (device_param->d_scryptV0_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_scryptV0_buf);
18578       if (device_param->d_scryptV1_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_scryptV1_buf);
18579       if (device_param->d_scryptV2_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_scryptV2_buf);
18580       if (device_param->d_scryptV3_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_scryptV3_buf);
18581       if (device_param->d_root_css_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_root_css_buf);
18582       if (device_param->d_markov_css_buf)   hc_clReleaseMemObject     (data.ocl, device_param->d_markov_css_buf);
18583       if (device_param->d_tm_c)             hc_clReleaseMemObject     (data.ocl, device_param->d_tm_c);
18584
18585       if (device_param->kernel1)            hc_clReleaseKernel        (data.ocl, device_param->kernel1);
18586       if (device_param->kernel12)           hc_clReleaseKernel        (data.ocl, device_param->kernel12);
18587       if (device_param->kernel2)            hc_clReleaseKernel        (data.ocl, device_param->kernel2);
18588       if (device_param->kernel23)           hc_clReleaseKernel        (data.ocl, device_param->kernel23);
18589       if (device_param->kernel3)            hc_clReleaseKernel        (data.ocl, device_param->kernel3);
18590       if (device_param->kernel_mp)          hc_clReleaseKernel        (data.ocl, device_param->kernel_mp);
18591       if (device_param->kernel_mp_l)        hc_clReleaseKernel        (data.ocl, device_param->kernel_mp_l);
18592       if (device_param->kernel_mp_r)        hc_clReleaseKernel        (data.ocl, device_param->kernel_mp_r);
18593       if (device_param->kernel_tm)          hc_clReleaseKernel        (data.ocl, device_param->kernel_tm);
18594       if (device_param->kernel_amp)         hc_clReleaseKernel        (data.ocl, device_param->kernel_amp);
18595       if (device_param->kernel_memset)      hc_clReleaseKernel        (data.ocl, device_param->kernel_memset);
18596
18597       if (device_param->program)            hc_clReleaseProgram       (data.ocl, device_param->program);
18598       if (device_param->program_mp)         hc_clReleaseProgram       (data.ocl, device_param->program_mp);
18599       if (device_param->program_amp)        hc_clReleaseProgram       (data.ocl, device_param->program_amp);
18600
18601       if (device_param->command_queue)      hc_clReleaseCommandQueue  (data.ocl, device_param->command_queue);
18602       if (device_param->context)            hc_clReleaseContext       (data.ocl, device_param->context);
18603     }
18604
18605     // reset default fan speed
18606
18607     #ifdef HAVE_HWMON
18608     if (gpu_temp_disable == 0)
18609     {
18610       if (gpu_temp_retain != 0)
18611       {
18612         hc_thread_mutex_lock (mux_adl);
18613
18614         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18615         {
18616           hc_device_param_t *device_param = &data.devices_param[device_id];
18617
18618           if (device_param->skipped) continue;
18619
18620           if (data.hm_device[device_id].fan_set_supported == 1)
18621           {
18622             int rc = -1;
18623
18624             if (device_param->device_vendor_id == VENDOR_ID_AMD)
18625             {
18626               rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18627             }
18628             else if (device_param->device_vendor_id == VENDOR_ID_NV)
18629             {
18630               #ifdef LINUX
18631               rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18632               #endif
18633
18634               #ifdef WIN
18635               rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18636               #endif
18637             }
18638
18639             if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18640           }
18641         }
18642
18643         hc_thread_mutex_unlock (mux_adl);
18644       }
18645     }
18646
18647     // reset power tuning
18648
18649     if (powertune_enable == 1)
18650     {
18651       hc_thread_mutex_lock (mux_adl);
18652
18653       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18654       {
18655         hc_device_param_t *device_param = &data.devices_param[device_id];
18656
18657         if (device_param->skipped) continue;
18658
18659         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18660         {
18661           if (data.hm_device[device_id].od_version == 6)
18662           {
18663             // check powertune capabilities first, if not available then skip device
18664
18665             int powertune_supported = 0;
18666
18667             if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18668             {
18669               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18670
18671               return (-1);
18672             }
18673
18674             if (powertune_supported != 0)
18675             {
18676               // powercontrol settings
18677
18678               if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18679               {
18680                 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18681
18682                 return (-1);
18683               }
18684
18685               // clocks
18686
18687               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18688
18689               performance_state->iNumberOfPerformanceLevels = 2;
18690
18691               performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18692               performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18693               performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18694               performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18695
18696               if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18697               {
18698                 log_info ("ERROR: Failed to restore ADL performance state");
18699
18700                 return (-1);
18701               }
18702
18703               local_free (performance_state);
18704             }
18705           }
18706         }
18707
18708         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18709         {
18710           unsigned int limit = nvml_power_limit[device_id];
18711
18712           if (limit > 0)
18713           {
18714             hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18715           }
18716         }
18717       }
18718
18719       hc_thread_mutex_unlock (mux_adl);
18720     }
18721
18722     if (gpu_temp_disable == 0)
18723     {
18724       if (data.hm_nvml)
18725       {
18726         hm_NVML_nvmlShutdown (data.hm_nvml);
18727
18728         nvml_close (data.hm_nvml);
18729
18730         data.hm_nvml = NULL;
18731       }
18732
18733       if (data.hm_nvapi)
18734       {
18735         hm_NvAPI_Unload (data.hm_nvapi);
18736
18737         nvapi_close (data.hm_nvapi);
18738
18739         data.hm_nvapi = NULL;
18740       }
18741
18742       if (data.hm_xnvctrl)
18743       {
18744         hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18745
18746         xnvctrl_close (data.hm_xnvctrl);
18747
18748         data.hm_xnvctrl = NULL;
18749       }
18750
18751       if (data.hm_adl)
18752       {
18753         hm_ADL_Main_Control_Destroy (data.hm_adl);
18754
18755         adl_close (data.hm_adl);
18756
18757         data.hm_adl = NULL;
18758       }
18759     }
18760     #endif // HAVE_HWMON
18761
18762     // free memory
18763
18764     local_free (masks);
18765
18766     local_free (dictstat_base);
18767
18768     for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18769     {
18770       pot_t *pot_ptr = &pot[pot_pos];
18771
18772       hash_t *hash = &pot_ptr->hash;
18773
18774       local_free (hash->digest);
18775
18776       if (isSalted)
18777       {
18778         local_free (hash->salt);
18779       }
18780     }
18781
18782     local_free (pot);
18783
18784     local_free (all_kernel_rules_cnt);
18785     local_free (all_kernel_rules_buf);
18786
18787     local_free (wl_data->buf);
18788     local_free (wl_data);
18789
18790     local_free (bitmap_s1_a);
18791     local_free (bitmap_s1_b);
18792     local_free (bitmap_s1_c);
18793     local_free (bitmap_s1_d);
18794     local_free (bitmap_s2_a);
18795     local_free (bitmap_s2_b);
18796     local_free (bitmap_s2_c);
18797     local_free (bitmap_s2_d);
18798
18799     #ifdef HAVE_HWMON
18800     local_free (od_clock_mem_status);
18801     local_free (od_power_control_status);
18802     local_free (nvml_power_limit);
18803     #endif
18804
18805     global_free (devices_param);
18806
18807     global_free (kernel_rules_buf);
18808
18809     global_free (root_css_buf);
18810     global_free (markov_css_buf);
18811
18812     global_free (digests_buf);
18813     global_free (digests_shown);
18814     global_free (digests_shown_tmp);
18815
18816     global_free (salts_buf);
18817     global_free (salts_shown);
18818
18819     global_free (esalts_buf);
18820
18821     global_free (words_progress_done);
18822     global_free (words_progress_rejected);
18823     global_free (words_progress_restored);
18824
18825     if (pot_fp) fclose (pot_fp);
18826
18827     if (data.devices_status == STATUS_QUIT) break;
18828   }
18829
18830   // wait for outer threads
18831
18832   data.shutdown_outer = 1;
18833
18834   for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18835   {
18836     hc_thread_wait (1, &outer_threads[thread_idx]);
18837   }
18838
18839   local_free (outer_threads);
18840
18841   // destroy others mutex
18842
18843   hc_thread_mutex_delete (mux_dispatcher);
18844   hc_thread_mutex_delete (mux_counter);
18845   hc_thread_mutex_delete (mux_display);
18846   hc_thread_mutex_delete (mux_adl);
18847
18848   // free memory
18849
18850   local_free (eff_restore_file);
18851   local_free (new_restore_file);
18852
18853   local_free (rd);
18854
18855   // tuning db
18856
18857   tuning_db_destroy (tuning_db);
18858
18859   // loopback
18860
18861   local_free (loopback_file);
18862
18863   if (loopback == 1) unlink (loopback_file);
18864
18865   // induction directory
18866
18867   if (induction_dir == NULL)
18868   {
18869     if (attack_mode != ATTACK_MODE_BF)
18870     {
18871       if (rmdir (induction_directory) == -1)
18872       {
18873         if (errno == ENOENT)
18874         {
18875           // good, we can ignore
18876         }
18877         else if (errno == ENOTEMPTY)
18878         {
18879           // good, we can ignore
18880         }
18881         else
18882         {
18883           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18884
18885           return (-1);
18886         }
18887       }
18888
18889       local_free (induction_directory);
18890     }
18891   }
18892
18893   // outfile-check directory
18894
18895   if (outfile_check_dir == NULL)
18896   {
18897     if (rmdir (outfile_check_directory) == -1)
18898     {
18899       if (errno == ENOENT)
18900       {
18901         // good, we can ignore
18902       }
18903       else if (errno == ENOTEMPTY)
18904       {
18905         // good, we can ignore
18906       }
18907       else
18908       {
18909         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18910
18911         return (-1);
18912       }
18913     }
18914
18915     local_free (outfile_check_directory);
18916   }
18917
18918   time_t proc_stop;
18919
18920   time (&proc_stop);
18921
18922   logfile_top_uint (proc_start);
18923   logfile_top_uint (proc_stop);
18924
18925   logfile_top_msg ("STOP");
18926
18927   if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18928   if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18929
18930   if (data.ocl) ocl_close (data.ocl);
18931
18932   if (data.devices_status == STATUS_ABORTED)            return 2;
18933   if (data.devices_status == STATUS_QUIT)               return 2;
18934   if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18935   if (data.devices_status == STATUS_EXHAUSTED)          return 1;
18936   if (data.devices_status == STATUS_CRACKED)            return 0;
18937
18938   return -1;
18939 }