src/hashcat.c

   1  /**
   2  * Authors.....: Jens Steube <jens.steube@gmail.com>
   3  *               Gabriele Gristina <matrix@hashcat.net>
   4  *               magnum <john.magnum@hushmail.com>
   5  *
   6  * License.....: MIT
   7  */
   8
   9 #ifdef OSX
  10 #include <stdio.h>
  11 #endif
  12
  13 #include <common.h>
  14 #include <shared.h>
  15 #include <rp_kernel_on_cpu.h>
  16 #include <getopt.h>
  17
  18 const char *PROGNAME            = "hashcat";
  19 const uint  VERSION_BIN         = 300;
  20 const uint  RESTORE_MIN         = 300;
  21
  22 double TARGET_MS_PROFILE[4]     = { 2, 12, 96, 480 };
  23
  24 #define INCR_RULES              10000
  25 #define INCR_SALTS              100000
  26 #define INCR_MASKS              1000
  27 #define INCR_POT                1000
  28
  29 #define USAGE                   0
  30 #define VERSION                 0
  31 #define QUIET                   0
  32 #define MARKOV_THRESHOLD        0
  33 #define MARKOV_DISABLE          0
  34 #define MARKOV_CLASSIC          0
  35 #define BENCHMARK               0
  36 #define 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         65
  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  16
  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   #ifdef _WIN
 920   fputc ('\r', out);
 921   fputc ('\n', out);
 922   #endif
 923
 924   #ifdef _POSIX
 925   fputc ('\n', out);
 926   #endif
 927
 928   fflush (out);
 929 }
 930
 931 void status_display ()
 932 {
 933   if (data.devices_status == STATUS_INIT)     return;
 934   if (data.devices_status == STATUS_STARTING) return;
 935   if (data.devices_status == STATUS_BYPASS)   return;
 936
 937   if (data.machine_readable == 1)
 938   {
 939     status_display_machine_readable ();
 940
 941     return;
 942   }
 943
 944   char tmp_buf[1000] = { 0 };
 945
 946   uint tmp_len = 0;
 947
 948   log_info ("Session.Name...: %s", data.session);
 949
 950   char *status_type = strstatus (data.devices_status);
 951
 952   uint hash_mode = data.hash_mode;
 953
 954   char *hash_type = strhashtype (hash_mode); // not a bug
 955
 956   log_info ("Status.........: %s", status_type);
 957
 958   /**
 959    * show rules
 960    */
 961
 962   if (data.rp_files_cnt)
 963   {
 964     uint i;
 965
 966     for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
 967     {
 968       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
 969     }
 970
 971     snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
 972
 973     log_info ("Rules.Type.....: %s", tmp_buf);
 974
 975     tmp_len = 0;
 976   }
 977
 978   if (data.rp_gen)
 979   {
 980     log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
 981
 982     if (data.rp_gen_seed)
 983     {
 984       log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
 985     }
 986   }
 987
 988   /**
 989    * show input
 990    */
 991
 992   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
 993   {
 994     if (data.wordlist_mode == WL_MODE_FILE)
 995     {
 996       if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
 997     }
 998     else if (data.wordlist_mode == WL_MODE_STDIN)
 999     {
1000       log_info ("Input.Mode.....: Pipe");
1001     }
1002   }
1003   else if (data.attack_mode == ATTACK_MODE_COMBI)
1004   {
1005     if (data.dictfile  != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1006     if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1007   }
1008   else if (data.attack_mode == ATTACK_MODE_BF)
1009   {
1010     char *mask = data.mask;
1011
1012     if (mask != NULL)
1013     {
1014       uint mask_len = data.css_cnt;
1015
1016       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1017
1018       if (mask_len > 0)
1019       {
1020         if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1021         {
1022           if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1023           {
1024             mask_len -= data.salts_buf[0].salt_len;
1025           }
1026         }
1027
1028         if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1029
1030         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1031       }
1032
1033       if (data.maskcnt > 1)
1034       {
1035         float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1036
1037         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1038       }
1039
1040       log_info ("Input.Mode.....: %s", tmp_buf);
1041     }
1042
1043     tmp_len = 0;
1044   }
1045   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1046   {
1047     if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1048     if (data.mask     != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049   }
1050   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1051   {
1052     if (data.mask     != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1053     if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1054   }
1055
1056   if (data.digests_cnt == 1)
1057   {
1058     if (data.hash_mode == 2500)
1059     {
1060       wpa_t *wpa = (wpa_t *) data.esalts_buf;
1061
1062       log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1063                 (char *) data.salts_buf[0].salt_buf,
1064                 wpa->orig_mac1[0],
1065                 wpa->orig_mac1[1],
1066                 wpa->orig_mac1[2],
1067                 wpa->orig_mac1[3],
1068                 wpa->orig_mac1[4],
1069                 wpa->orig_mac1[5],
1070                 wpa->orig_mac2[0],
1071                 wpa->orig_mac2[1],
1072                 wpa->orig_mac2[2],
1073                 wpa->orig_mac2[3],
1074                 wpa->orig_mac2[4],
1075                 wpa->orig_mac2[5]);
1076     }
1077     else if (data.hash_mode == 5200)
1078     {
1079       log_info ("Hash.Target....: File (%s)", data.hashfile);
1080     }
1081     else if (data.hash_mode == 9000)
1082     {
1083       log_info ("Hash.Target....: File (%s)", data.hashfile);
1084     }
1085     else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1086     {
1087       log_info ("Hash.Target....: File (%s)", data.hashfile);
1088     }
1089     else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1090     {
1091       log_info ("Hash.Target....: File (%s)", data.hashfile);
1092     }
1093     else
1094     {
1095       char out_buf[HCBUFSIZ] = { 0 };
1096
1097       ascii_digest (out_buf, 0, 0);
1098
1099       // limit length
1100       if (strlen (out_buf) > 40)
1101       {
1102         out_buf[41] = '.';
1103         out_buf[42] = '.';
1104         out_buf[43] = '.';
1105         out_buf[44] = 0;
1106       }
1107
1108       log_info ("Hash.Target....: %s", out_buf);
1109     }
1110   }
1111   else
1112   {
1113     if (data.hash_mode == 3000)
1114     {
1115       char out_buf1[32] = { 0 };
1116       char out_buf2[32] = { 0 };
1117
1118       ascii_digest (out_buf1, 0, 0);
1119       ascii_digest (out_buf2, 0, 1);
1120
1121       log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1122     }
1123     else
1124     {
1125       log_info ("Hash.Target....: File (%s)", data.hashfile);
1126     }
1127   }
1128
1129   log_info ("Hash.Type......: %s", hash_type);
1130
1131   /**
1132    * speed new
1133    */
1134
1135   u64    speed_cnt[DEVICES_MAX] = { 0 };
1136   double speed_ms[DEVICES_MAX]  = { 0 };
1137
1138   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1139   {
1140     hc_device_param_t *device_param = &data.devices_param[device_id];
1141
1142     if (device_param->skipped) continue;
1143
1144     speed_cnt[device_id] = 0;
1145     speed_ms[device_id]  = 0;
1146
1147     for (int i = 0; i < SPEED_CACHE; i++)
1148     {
1149       speed_cnt[device_id] += device_param->speed_cnt[i];
1150       speed_ms[device_id]  += device_param->speed_ms[i];
1151     }
1152
1153     speed_cnt[device_id] /= SPEED_CACHE;
1154     speed_ms[device_id]  /= SPEED_CACHE;
1155   }
1156
1157   double hashes_all_ms = 0;
1158
1159   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1160
1161   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162   {
1163     hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165     if (device_param->skipped) continue;
1166
1167     hashes_dev_ms[device_id] = 0;
1168
1169     if (speed_ms[device_id])
1170     {
1171       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1172
1173       hashes_all_ms += hashes_dev_ms[device_id];
1174     }
1175   }
1176
1177   /**
1178    * exec time
1179    */
1180
1181   double exec_all_ms[DEVICES_MAX] = { 0 };
1182
1183   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1184   {
1185     hc_device_param_t *device_param = &data.devices_param[device_id];
1186
1187     if (device_param->skipped) continue;
1188
1189     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1190
1191     exec_all_ms[device_id] = exec_ms_avg;
1192   }
1193
1194   /**
1195    * timers
1196    */
1197
1198   double ms_running = 0;
1199
1200   hc_timer_get (data.timer_running, ms_running);
1201
1202   double ms_paused = data.ms_paused;
1203
1204   if (data.devices_status == STATUS_PAUSED)
1205   {
1206     double ms_paused_tmp = 0;
1207
1208     hc_timer_get (data.timer_paused, ms_paused_tmp);
1209
1210     ms_paused += ms_paused_tmp;
1211   }
1212
1213   #ifdef WIN
1214
1215   __time64_t sec_run = ms_running / 1000;
1216
1217   #else
1218
1219   time_t sec_run = ms_running / 1000;
1220
1221   #endif
1222
1223   if (sec_run)
1224   {
1225     char display_run[32] = { 0 };
1226
1227     struct tm tm_run;
1228
1229     struct tm *tmp = NULL;
1230
1231     #ifdef WIN
1232
1233     tmp = _gmtime64 (&sec_run);
1234
1235     #else
1236
1237     tmp = gmtime (&sec_run);
1238
1239     #endif
1240
1241     if (tmp != NULL)
1242     {
1243       memset (&tm_run, 0, sizeof (tm_run));
1244
1245       memcpy (&tm_run, tmp, sizeof (tm_run));
1246
1247       format_timer_display (&tm_run, display_run, sizeof (tm_run));
1248
1249       char *start = ctime (&data.proc_start);
1250
1251       size_t start_len = strlen (start);
1252
1253       if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1254       if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1255
1256       log_info ("Time.Started...: %s (%s)", start, display_run);
1257     }
1258   }
1259   else
1260   {
1261     log_info ("Time.Started...: 0 secs");
1262   }
1263
1264   /**
1265    * counters
1266    */
1267
1268   u64 progress_total = data.words_cnt * data.salts_cnt;
1269
1270   u64 all_done     = 0;
1271   u64 all_rejected = 0;
1272   u64 all_restored = 0;
1273
1274   u64 progress_noneed = 0;
1275
1276   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1277   {
1278     all_done     += data.words_progress_done[salt_pos];
1279     all_rejected += data.words_progress_rejected[salt_pos];
1280     all_restored += data.words_progress_restored[salt_pos];
1281
1282     // Important for ETA only
1283
1284     if (data.salts_shown[salt_pos] == 1)
1285     {
1286       const u64 all = data.words_progress_done[salt_pos]
1287                     + data.words_progress_rejected[salt_pos]
1288                     + data.words_progress_restored[salt_pos];
1289
1290       const u64 left = data.words_cnt - all;
1291
1292       progress_noneed += left;
1293     }
1294   }
1295
1296   u64 progress_cur = all_restored + all_done + all_rejected;
1297   u64 progress_end = progress_total;
1298
1299   u64 progress_skip = 0;
1300
1301   if (data.skip)
1302   {
1303     progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1304
1305     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1306     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_skip *= data.combs_cnt;
1307     else if (data.attack_kern == ATTACK_KERN_BF)       progress_skip *= data.bfs_cnt;
1308   }
1309
1310   if (data.limit)
1311   {
1312     progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1313
1314     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end  *= data.kernel_rules_cnt;
1315     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_end  *= data.combs_cnt;
1316     else if (data.attack_kern == ATTACK_KERN_BF)       progress_end  *= data.bfs_cnt;
1317   }
1318
1319   u64 progress_cur_relative_skip = progress_cur - progress_skip;
1320   u64 progress_end_relative_skip = progress_end - progress_skip;
1321
1322   if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1323   {
1324     if (data.devices_status != STATUS_CRACKED)
1325     {
1326       #ifdef WIN
1327       __time64_t sec_etc = 0;
1328       #else
1329       time_t sec_etc = 0;
1330       #endif
1331
1332       if (hashes_all_ms)
1333       {
1334         u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1335
1336         u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1337
1338         sec_etc = ms_left / 1000;
1339       }
1340
1341       if (sec_etc == 0)
1342       {
1343         //log_info ("Time.Estimated.: 0 secs");
1344       }
1345       else if ((u64) sec_etc > ETC_MAX)
1346       {
1347         log_info ("Time.Estimated.: > 10 Years");
1348       }
1349       else
1350       {
1351         char display_etc[32] = { 0 };
1352
1353         struct tm tm_etc;
1354
1355         struct tm *tmp = NULL;
1356
1357         #ifdef WIN
1358
1359         tmp = _gmtime64 (&sec_etc);
1360
1361         #else
1362
1363         tmp = gmtime (&sec_etc);
1364
1365         #endif
1366
1367         if (tmp != NULL)
1368         {
1369           memset (&tm_etc, 0, sizeof (tm_etc));
1370
1371           memcpy (&tm_etc, tmp, sizeof (tm_etc));
1372
1373           format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1374
1375           time_t now;
1376
1377           time (&now);
1378
1379           now += sec_etc;
1380
1381           char *etc = ctime (&now);
1382
1383           size_t etc_len = strlen (etc);
1384
1385           if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1386           if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1387
1388           log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1389         }
1390       }
1391     }
1392   }
1393
1394   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1395   {
1396     hc_device_param_t *device_param = &data.devices_param[device_id];
1397
1398     if (device_param->skipped) continue;
1399
1400     char display_dev_cur[16] = { 0 };
1401
1402     strncpy (display_dev_cur, "0.00", 4);
1403
1404     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1405
1406     log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1407   }
1408
1409   char display_all_cur[16] = { 0 };
1410
1411   strncpy (display_all_cur, "0.00", 4);
1412
1413   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1414
1415   if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1416
1417   const float digests_percent = (float) data.digests_done / data.digests_cnt;
1418   const float salts_percent   = (float) data.salts_done   / data.salts_cnt;
1419
1420   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);
1421
1422   // crack-per-time
1423
1424   if (data.digests_cnt > 100)
1425   {
1426     time_t now = time (NULL);
1427
1428     int cpt_cur_min  = 0;
1429     int cpt_cur_hour = 0;
1430     int cpt_cur_day  = 0;
1431
1432     for (int i = 0; i < CPT_BUF; i++)
1433     {
1434       const uint   cracked   = data.cpt_buf[i].cracked;
1435       const time_t timestamp = data.cpt_buf[i].timestamp;
1436
1437       if ((timestamp + 60) > now)
1438       {
1439         cpt_cur_min  += cracked;
1440       }
1441
1442       if ((timestamp + 3600) > now)
1443       {
1444         cpt_cur_hour += cracked;
1445       }
1446
1447       if ((timestamp + 86400) > now)
1448       {
1449         cpt_cur_day  += cracked;
1450       }
1451     }
1452
1453     double ms_real = ms_running - ms_paused;
1454
1455     float cpt_avg_min  = (float) data.cpt_total / ((ms_real / 1000) / 60);
1456     float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1457     float cpt_avg_day  = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1458
1459     if ((data.cpt_start + 86400) < now)
1460     {
1461       log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1462         cpt_cur_min,
1463         cpt_cur_hour,
1464         cpt_cur_day,
1465         cpt_avg_min,
1466         cpt_avg_hour,
1467         cpt_avg_day);
1468     }
1469     else if ((data.cpt_start + 3600) < now)
1470     {
1471       log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472         cpt_cur_min,
1473         cpt_cur_hour,
1474         cpt_avg_min,
1475         cpt_avg_hour,
1476         cpt_avg_day);
1477     }
1478     else if ((data.cpt_start + 60) < now)
1479     {
1480       log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1481         cpt_cur_min,
1482         cpt_avg_min,
1483         cpt_avg_hour,
1484         cpt_avg_day);
1485     }
1486     else
1487     {
1488       log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1489         cpt_avg_min,
1490         cpt_avg_hour,
1491         cpt_avg_day);
1492     }
1493   }
1494
1495   // Restore point
1496
1497   u64 restore_point = get_lowest_words_done ();
1498
1499   u64 restore_total = data.words_base;
1500
1501   float percent_restore = 0;
1502
1503   if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1504
1505   if (progress_end_relative_skip)
1506   {
1507     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1508     {
1509       float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1510       float percent_rejected = 0.0;
1511
1512       if (progress_cur)
1513       {
1514         percent_rejected = (float) (all_rejected) / (float) progress_cur;
1515       }
1516
1517       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);
1518       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected,               (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1519
1520       if (data.restore_disable == 0)
1521       {
1522         if (percent_finished != 1)
1523         {
1524           log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1525         }
1526       }
1527     }
1528   }
1529   else
1530   {
1531     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532     {
1533       log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1534       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535
1536       if (data.restore_disable == 0)
1537       {
1538         log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539       }
1540     }
1541     else
1542     {
1543       log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1544       log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1545
1546       // --restore not allowed if stdin is used -- really? why?
1547
1548       //if (data.restore_disable == 0)
1549       //{
1550       //  log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1551       //}
1552     }
1553   }
1554
1555   #ifdef HAVE_HWMON
1556
1557   if (data.devices_status == STATUS_EXHAUSTED)  return;
1558   if (data.devices_status == STATUS_CRACKED)    return;
1559   if (data.devices_status == STATUS_ABORTED)    return;
1560   if (data.devices_status == STATUS_QUIT)       return;
1561
1562   if (data.gpu_temp_disable == 0)
1563   {
1564     hc_thread_mutex_lock (mux_adl);
1565
1566     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1567     {
1568       hc_device_param_t *device_param = &data.devices_param[device_id];
1569
1570       if (device_param->skipped) continue;
1571
1572       const int num_temperature = hm_get_temperature_with_device_id (device_id);
1573       const int num_fanspeed    = hm_get_fanspeed_with_device_id    (device_id);
1574       const int num_utilization = hm_get_utilization_with_device_id (device_id);
1575       const int num_corespeed   = hm_get_corespeed_with_device_id   (device_id);
1576       const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1577       const int num_buslanes    = hm_get_buslanes_with_device_id    (device_id);
1578       const int num_throttle    = hm_get_throttle_with_device_id    (device_id);
1579
1580       char output_buf[256] = { 0 };
1581
1582       int output_len = 0;
1583
1584       if (num_temperature >= 0)
1585       {
1586         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1587
1588         output_len = strlen (output_buf);
1589       }
1590
1591       if (num_fanspeed >= 0)
1592       {
1593         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1594
1595         output_len = strlen (output_buf);
1596       }
1597
1598       if (num_utilization >= 0)
1599       {
1600         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1601
1602         output_len = strlen (output_buf);
1603       }
1604
1605       if (num_corespeed >= 0)
1606       {
1607         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1608
1609         output_len = strlen (output_buf);
1610       }
1611
1612       if (num_memoryspeed >= 0)
1613       {
1614         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1615
1616         output_len = strlen (output_buf);
1617       }
1618
1619       if (num_buslanes >= 0)
1620       {
1621         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1622
1623         output_len = strlen (output_buf);
1624       }
1625
1626       if (num_throttle == 1)
1627       {
1628         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1629
1630         output_len = strlen (output_buf);
1631       }
1632
1633       if (output_len == 0)
1634       {
1635         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1636
1637         output_len = strlen (output_buf);
1638       }
1639
1640       log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1641     }
1642
1643     hc_thread_mutex_unlock (mux_adl);
1644   }
1645
1646   #endif // HAVE_HWMON
1647 }
1648
1649 static void status_benchmark_automate ()
1650 {
1651   u64    speed_cnt[DEVICES_MAX] = { 0 };
1652   double speed_ms[DEVICES_MAX]  = { 0 };
1653
1654   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1655   {
1656     hc_device_param_t *device_param = &data.devices_param[device_id];
1657
1658     if (device_param->skipped) continue;
1659
1660     speed_cnt[device_id] = device_param->speed_cnt[0];
1661     speed_ms[device_id]  = device_param->speed_ms[0];
1662   }
1663
1664   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1665
1666   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667   {
1668     hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670     if (device_param->skipped) continue;
1671
1672     hashes_dev_ms[device_id] = 0;
1673
1674     if (speed_ms[device_id])
1675     {
1676       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1677     }
1678   }
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     log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1687   }
1688 }
1689
1690 static void status_benchmark ()
1691 {
1692   if (data.devices_status == STATUS_INIT)     return;
1693   if (data.devices_status == STATUS_STARTING) return;
1694   if (data.devices_status == STATUS_BYPASS)   return;
1695
1696   if (data.machine_readable == 1)
1697   {
1698     status_benchmark_automate ();
1699
1700     return;
1701   }
1702
1703   u64    speed_cnt[DEVICES_MAX] = { 0 };
1704   double speed_ms[DEVICES_MAX]  = { 0 };
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     speed_cnt[device_id] = device_param->speed_cnt[0];
1713     speed_ms[device_id]  = device_param->speed_ms[0];
1714   }
1715
1716   double hashes_all_ms = 0;
1717
1718   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1719
1720   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1721   {
1722     hc_device_param_t *device_param = &data.devices_param[device_id];
1723
1724     if (device_param->skipped) continue;
1725
1726     hashes_dev_ms[device_id] = 0;
1727
1728     if (speed_ms[device_id])
1729     {
1730       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1731
1732       hashes_all_ms += hashes_dev_ms[device_id];
1733     }
1734   }
1735
1736   /**
1737    * exec time
1738    */
1739
1740   double exec_all_ms[DEVICES_MAX] = { 0 };
1741
1742   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1743   {
1744     hc_device_param_t *device_param = &data.devices_param[device_id];
1745
1746     if (device_param->skipped) continue;
1747
1748     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1749
1750     exec_all_ms[device_id] = exec_ms_avg;
1751   }
1752
1753   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1754   {
1755     hc_device_param_t *device_param = &data.devices_param[device_id];
1756
1757     if (device_param->skipped) continue;
1758
1759     char display_dev_cur[16] = { 0 };
1760
1761     strncpy (display_dev_cur, "0.00", 4);
1762
1763     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1764
1765     if (data.devices_active >= 10)
1766     {
1767       log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1768     }
1769     else
1770     {
1771       log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1772     }
1773   }
1774
1775   char display_all_cur[16] = { 0 };
1776
1777   strncpy (display_all_cur, "0.00", 4);
1778
1779   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1780
1781   if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1782 }
1783
1784 /**
1785  * hashcat -only- functions
1786  */
1787
1788 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1789 {
1790   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1791   {
1792     if (attack_kern == ATTACK_KERN_STRAIGHT)
1793       snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1794     else if (attack_kern == ATTACK_KERN_COMBI)
1795       snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1796     else if (attack_kern == ATTACK_KERN_BF)
1797       snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1798   }
1799   else
1800     snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1801 }
1802
1803 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)
1804 {
1805   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1806   {
1807     if (attack_kern == ATTACK_KERN_STRAIGHT)
1808       snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1809     else if (attack_kern == ATTACK_KERN_COMBI)
1810       snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1811     else if (attack_kern == ATTACK_KERN_BF)
1812       snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1813   }
1814   else
1815   {
1816     snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1817   }
1818 }
1819
1820 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1821 {
1822   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1823   {
1824     snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1825   }
1826   else
1827   {
1828     snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1829   }
1830 }
1831
1832 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)
1833 {
1834   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1835   {
1836     snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1837   }
1838   else
1839   {
1840     snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1841   }
1842 }
1843
1844 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1845 {
1846   snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1847 }
1848
1849 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1850 {
1851   snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1852 }
1853
1854 static char *filename_from_filepath (char *filepath)
1855 {
1856   char *ptr = NULL;
1857
1858   if ((ptr = strrchr (filepath, '/')) != NULL)
1859   {
1860     ptr++;
1861   }
1862   else if ((ptr = strrchr (filepath, '\\')) != NULL)
1863   {
1864     ptr++;
1865   }
1866   else
1867   {
1868     ptr = filepath;
1869   }
1870
1871   return ptr;
1872 }
1873
1874 static uint convert_from_hex (char *line_buf, const uint line_len)
1875 {
1876   if (line_len & 1) return (line_len); // not in hex
1877
1878   if (data.hex_wordlist == 1)
1879   {
1880     uint i;
1881     uint j;
1882
1883     for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1884     {
1885       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1886     }
1887
1888     memset (line_buf + i, 0, line_len - i);
1889
1890     return (i);
1891   }
1892   else if (line_len >= 6) // $HEX[] = 6
1893   {
1894     if (line_buf[0]            != '$') return (line_len);
1895     if (line_buf[1]            != 'H') return (line_len);
1896     if (line_buf[2]            != 'E') return (line_len);
1897     if (line_buf[3]            != 'X') return (line_len);
1898     if (line_buf[4]            != '[') return (line_len);
1899     if (line_buf[line_len - 1] != ']') return (line_len);
1900
1901     uint i;
1902     uint j;
1903
1904     for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1905     {
1906       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1907     }
1908
1909     memset (line_buf + i, 0, line_len - i);
1910
1911     return (i);
1912   }
1913
1914   return (line_len);
1915 }
1916
1917 static void clear_prompt ()
1918 {
1919   fputc ('\r', stdout);
1920
1921   for (size_t i = 0; i < strlen (PROMPT); i++)
1922   {
1923     fputc (' ', stdout);
1924   }
1925
1926   fputc ('\r', stdout);
1927
1928   fflush (stdout);
1929 }
1930
1931 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1932 {
1933   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);
1934 }
1935
1936 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1937 {
1938   char *outfile    = data.outfile;
1939   uint  quiet      = data.quiet;
1940   FILE *pot_fp     = data.pot_fp;
1941   uint  loopback   = data.loopback;
1942   uint  debug_mode = data.debug_mode;
1943   char *debug_file = data.debug_file;
1944
1945   char debug_rule_buf[BLOCK_SIZE] = { 0 };
1946   int  debug_rule_len  = 0; // -1 error
1947   uint debug_plain_len = 0;
1948
1949   u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1950
1951   // hash
1952
1953   char out_buf[HCBUFSIZ] = { 0 };
1954
1955   const u32 salt_pos    = plain->salt_pos;
1956   const u32 digest_pos  = plain->digest_pos;  // relative
1957   const u32 gidvid      = plain->gidvid;
1958   const u32 il_pos      = plain->il_pos;
1959
1960   ascii_digest (out_buf, salt_pos, digest_pos);
1961
1962   // plain
1963
1964   u64 crackpos = device_param->words_off;
1965
1966   uint plain_buf[16] = { 0 };
1967
1968   u8 *plain_ptr = (u8 *) plain_buf;
1969
1970   unsigned int plain_len = 0;
1971
1972   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1973   {
1974     pw_t pw;
1975
1976     gidd_to_pw_t (device_param, gidvid, &pw);
1977
1978     for (int i = 0; i < 16; i++)
1979     {
1980       plain_buf[i] = pw.i[i];
1981     }
1982
1983     plain_len = pw.pw_len;
1984
1985     const uint off = device_param->innerloop_pos + il_pos;
1986
1987     if (debug_mode > 0)
1988     {
1989       debug_rule_len = 0;
1990
1991       // save rule
1992       if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1993       {
1994         memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1995
1996         debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1997       }
1998
1999       // save plain
2000       if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2001       {
2002         memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2003
2004         memcpy (debug_plain_ptr, plain_ptr, plain_len);
2005
2006         debug_plain_len = plain_len;
2007       }
2008     }
2009
2010     plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2011
2012     crackpos += gidvid;
2013     crackpos *= data.kernel_rules_cnt;
2014     crackpos += device_param->innerloop_pos + il_pos;
2015
2016     if (plain_len > data.pw_max) plain_len = data.pw_max;
2017   }
2018   else if (data.attack_mode == ATTACK_MODE_COMBI)
2019   {
2020     pw_t pw;
2021
2022     gidd_to_pw_t (device_param, gidvid, &pw);
2023
2024     for (int i = 0; i < 16; i++)
2025     {
2026       plain_buf[i] = pw.i[i];
2027     }
2028
2029     plain_len = pw.pw_len;
2030
2031     char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2032     uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2033
2034     if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2035     {
2036       memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2037     }
2038     else
2039     {
2040       memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2041
2042       memcpy (plain_ptr, comb_buf, comb_len);
2043     }
2044
2045     plain_len += comb_len;
2046
2047     crackpos += gidvid;
2048     crackpos *= data.combs_cnt;
2049     crackpos += device_param->innerloop_pos + il_pos;
2050
2051     if (data.pw_max != PW_DICTMAX1)
2052     {
2053       if (plain_len > data.pw_max) plain_len = data.pw_max;
2054     }
2055   }
2056   else if (data.attack_mode == ATTACK_MODE_BF)
2057   {
2058     u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2059     u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2060
2061     uint l_start = device_param->kernel_params_mp_l_buf32[5];
2062     uint r_start = device_param->kernel_params_mp_r_buf32[5];
2063
2064     uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2065     uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2066
2067     sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2068     sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2069
2070     plain_len = data.css_cnt;
2071
2072     crackpos += gidvid;
2073     crackpos *= data.bfs_cnt;
2074     crackpos += device_param->innerloop_pos + il_pos;
2075   }
2076   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2077   {
2078     pw_t pw;
2079
2080     gidd_to_pw_t (device_param, gidvid, &pw);
2081
2082     for (int i = 0; i < 16; i++)
2083     {
2084       plain_buf[i] = pw.i[i];
2085     }
2086
2087     plain_len = pw.pw_len;
2088
2089     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2090
2091     uint start = 0;
2092     uint stop  = device_param->kernel_params_mp_buf32[4];
2093
2094     sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2095
2096     plain_len += start + stop;
2097
2098     crackpos += gidvid;
2099     crackpos *= data.combs_cnt;
2100     crackpos += device_param->innerloop_pos + il_pos;
2101
2102     if (data.pw_max != PW_DICTMAX1)
2103     {
2104       if (plain_len > data.pw_max) plain_len = data.pw_max;
2105     }
2106   }
2107   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2108   {
2109     pw_t pw;
2110
2111     gidd_to_pw_t (device_param, gidvid, &pw);
2112
2113     for (int i = 0; i < 16; i++)
2114     {
2115       plain_buf[i] = pw.i[i];
2116     }
2117
2118     plain_len = pw.pw_len;
2119
2120     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2121
2122     uint start = 0;
2123     uint stop  = device_param->kernel_params_mp_buf32[4];
2124
2125     memmove (plain_ptr + stop, plain_ptr, plain_len);
2126
2127     sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2128
2129     plain_len += start + stop;
2130
2131     crackpos += gidvid;
2132     crackpos *= data.combs_cnt;
2133     crackpos += device_param->innerloop_pos + il_pos;
2134
2135     if (data.pw_max != PW_DICTMAX1)
2136     {
2137       if (plain_len > data.pw_max) plain_len = data.pw_max;
2138     }
2139   }
2140
2141   if (data.attack_mode == ATTACK_MODE_BF)
2142   {
2143     if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2144     {
2145       if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2146       {
2147         if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2148         {
2149           plain_len = plain_len - data.salts_buf[0].salt_len;
2150         }
2151       }
2152
2153       if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2154       {
2155         for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2156         {
2157           plain_ptr[j] = plain_ptr[i];
2158         }
2159
2160         plain_len = plain_len / 2;
2161       }
2162     }
2163   }
2164
2165   // if enabled, update also the potfile
2166
2167   if (pot_fp)
2168   {
2169     lock_file (pot_fp);
2170
2171     fprintf (pot_fp, "%s:", out_buf);
2172
2173     format_plain (pot_fp, plain_ptr, plain_len, 1);
2174
2175     fputc ('\n', pot_fp);
2176
2177     fflush (pot_fp);
2178
2179     unlock_file (pot_fp);
2180   }
2181
2182   // outfile
2183
2184   FILE *out_fp = NULL;
2185
2186   if (outfile != NULL)
2187   {
2188     if ((out_fp = fopen (outfile, "ab")) == NULL)
2189     {
2190       log_error ("ERROR: %s: %s", outfile, strerror (errno));
2191
2192       out_fp = stdout;
2193     }
2194
2195     lock_file (out_fp);
2196   }
2197   else
2198   {
2199     out_fp = stdout;
2200
2201     if (quiet == 0) clear_prompt ();
2202   }
2203
2204   format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2205
2206   if (outfile != NULL)
2207   {
2208     if (out_fp != stdout)
2209     {
2210       fclose (out_fp);
2211     }
2212   }
2213   else
2214   {
2215     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2216     {
2217       if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2218       {
2219         if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2220         if (quiet == 0) fflush (stdout);
2221       }
2222     }
2223   }
2224
2225   // loopback
2226
2227   if (loopback)
2228   {
2229     char *loopback_file = data.loopback_file;
2230
2231     FILE *fb_fp = NULL;
2232
2233     if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2234     {
2235       lock_file (fb_fp);
2236
2237       format_plain (fb_fp, plain_ptr, plain_len, 1);
2238
2239       fputc ('\n', fb_fp);
2240
2241       fclose (fb_fp);
2242     }
2243   }
2244
2245   // (rule) debug mode
2246
2247   // the next check implies that:
2248   // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2249   // - debug_mode > 0
2250
2251   if ((debug_plain_len > 0) || (debug_rule_len > 0))
2252   {
2253     if (debug_rule_len < 0) debug_rule_len = 0;
2254
2255     if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2256
2257     format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2258
2259     if ((quiet == 0) && (debug_file == NULL))
2260     {
2261       fprintf (stdout, "%s", PROMPT);
2262
2263       fflush (stdout);
2264     }
2265   }
2266 }
2267
2268 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2269 {
2270   salt_t *salt_buf = &data.salts_buf[salt_pos];
2271
2272   u32 num_cracked;
2273
2274   hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2275
2276   if (num_cracked)
2277   {
2278     // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2279
2280     log_info_nn ("");
2281
2282     plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2283
2284     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);
2285
2286     uint cpt_cracked = 0;
2287
2288     hc_thread_mutex_lock (mux_display);
2289
2290     for (uint i = 0; i < num_cracked; i++)
2291     {
2292       const uint hash_pos = cracked[i].hash_pos;
2293
2294       if (data.digests_shown[hash_pos] == 1) continue;
2295
2296       if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2297       {
2298         data.digests_shown[hash_pos] = 1;
2299
2300         data.digests_done++;
2301
2302         cpt_cracked++;
2303
2304         salt_buf->digests_done++;
2305
2306         if (salt_buf->digests_done == salt_buf->digests_cnt)
2307         {
2308           data.salts_shown[salt_pos] = 1;
2309
2310           data.salts_done++;
2311         }
2312       }
2313
2314       if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2315
2316       check_hash (device_param, &cracked[i]);
2317     }
2318
2319     hc_thread_mutex_unlock (mux_display);
2320
2321     myfree (cracked);
2322
2323     if (cpt_cracked > 0)
2324     {
2325       hc_thread_mutex_lock (mux_display);
2326
2327       data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2328       data.cpt_buf[data.cpt_pos].cracked   = cpt_cracked;
2329
2330       data.cpt_pos++;
2331
2332       data.cpt_total += cpt_cracked;
2333
2334       if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2335
2336       hc_thread_mutex_unlock (mux_display);
2337     }
2338
2339     if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2340     {
2341       // we need to reset cracked state on the device
2342       // otherwise host thinks again and again the hash was cracked
2343       // and returns invalid password each time
2344
2345       memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2346
2347       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);
2348     }
2349
2350     num_cracked = 0;
2351
2352     hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2353   }
2354 }
2355
2356 // stolen from princeprocessor ;)
2357
2358 typedef struct
2359 {
2360   FILE *fp;
2361
2362   char  buf[BUFSIZ];
2363   int   len;
2364
2365 } out_t;
2366
2367 static void out_flush (out_t *out)
2368 {
2369   fwrite (out->buf, 1, out->len, out->fp);
2370
2371   out->len = 0;
2372 }
2373
2374 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2375 {
2376   char *ptr = out->buf + out->len;
2377
2378   memcpy (ptr, pw_buf, pw_len);
2379
2380   ptr[pw_len] = '\n';
2381
2382   out->len += pw_len + 1;
2383
2384   if (out->len >= BUFSIZ - 100)
2385   {
2386     out_flush (out);
2387   }
2388 }
2389
2390 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2391 {
2392   out_t out;
2393
2394   out.fp  = stdout;
2395   out.len = 0;
2396
2397   uint plain_buf[16] = { 0 };
2398
2399   u8 *plain_ptr = (u8 *) plain_buf;
2400
2401   uint plain_len = 0;
2402
2403   const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2404
2405   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2406   {
2407     pw_t pw;
2408
2409     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2410     {
2411       gidd_to_pw_t (device_param, gidvid, &pw);
2412
2413       const uint pos = device_param->innerloop_pos;
2414
2415       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2416       {
2417         for (int i = 0; i < 8; i++)
2418         {
2419           plain_buf[i] = pw.i[i];
2420         }
2421
2422         plain_len = pw.pw_len;
2423
2424         plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2425
2426         if (plain_len > data.pw_max) plain_len = data.pw_max;
2427
2428         out_push (&out, plain_ptr, plain_len);
2429       }
2430     }
2431   }
2432   else if (data.attack_mode == ATTACK_MODE_COMBI)
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       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2441       {
2442         for (int i = 0; i < 8; i++)
2443         {
2444           plain_buf[i] = pw.i[i];
2445         }
2446
2447         plain_len = pw.pw_len;
2448
2449         char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2450         uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2451
2452         if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2453         {
2454           memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2455         }
2456         else
2457         {
2458           memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2459
2460           memcpy (plain_ptr, comb_buf, comb_len);
2461         }
2462
2463         plain_len += comb_len;
2464
2465         if (data.pw_max != PW_DICTMAX1)
2466         {
2467           if (plain_len > data.pw_max) plain_len = data.pw_max;
2468         }
2469
2470         out_push (&out, plain_ptr, plain_len);
2471       }
2472     }
2473   }
2474   else if (data.attack_mode == ATTACK_MODE_BF)
2475   {
2476     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2477     {
2478       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2479       {
2480         u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2481         u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2482
2483         uint l_start = device_param->kernel_params_mp_l_buf32[5];
2484         uint r_start = device_param->kernel_params_mp_r_buf32[5];
2485
2486         uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2487         uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2488
2489         sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2490         sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2491
2492         plain_len = data.css_cnt;
2493
2494         out_push (&out, plain_ptr, plain_len);
2495       }
2496     }
2497   }
2498   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2499   {
2500     pw_t pw;
2501
2502     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2503     {
2504       gidd_to_pw_t (device_param, gidvid, &pw);
2505
2506       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2507       {
2508         for (int i = 0; i < 8; i++)
2509         {
2510           plain_buf[i] = pw.i[i];
2511         }
2512
2513         plain_len = pw.pw_len;
2514
2515         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2516
2517         uint start = 0;
2518         uint stop  = device_param->kernel_params_mp_buf32[4];
2519
2520         sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2521
2522         plain_len += start + stop;
2523
2524         out_push (&out, plain_ptr, plain_len);
2525       }
2526     }
2527   }
2528   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2529   {
2530     pw_t pw;
2531
2532     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2533     {
2534       gidd_to_pw_t (device_param, gidvid, &pw);
2535
2536       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2537       {
2538         for (int i = 0; i < 8; i++)
2539         {
2540           plain_buf[i] = pw.i[i];
2541         }
2542
2543         plain_len = pw.pw_len;
2544
2545         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2546
2547         uint start = 0;
2548         uint stop  = device_param->kernel_params_mp_buf32[4];
2549
2550         memmove (plain_ptr + stop, plain_ptr, plain_len);
2551
2552         sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2553
2554         plain_len += start + stop;
2555
2556         out_push (&out, plain_ptr, plain_len);
2557       }
2558     }
2559   }
2560
2561   out_flush (&out);
2562 }
2563
2564 static void save_hash ()
2565 {
2566   char *hashfile = data.hashfile;
2567
2568   char new_hashfile[256] = { 0 };
2569   char old_hashfile[256] = { 0 };
2570
2571   snprintf (new_hashfile, 255, "%s.new", hashfile);
2572   snprintf (old_hashfile, 255, "%s.old", hashfile);
2573
2574   unlink (new_hashfile);
2575
2576   char separator = data.separator;
2577
2578   FILE *fp = fopen (new_hashfile, "wb");
2579
2580   if (fp == NULL)
2581   {
2582     log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2583
2584     exit (-1);
2585   }
2586
2587   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2588   {
2589     if (data.salts_shown[salt_pos] == 1) continue;
2590
2591     salt_t *salt_buf = &data.salts_buf[salt_pos];
2592
2593     for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2594     {
2595       uint idx = salt_buf->digests_offset + digest_pos;
2596
2597       if (data.digests_shown[idx] == 1) continue;
2598
2599       if (data.hash_mode != 2500)
2600       {
2601         if (data.username == 1)
2602         {
2603           user_t *user = data.hash_info[idx]->user;
2604
2605           uint i;
2606
2607           for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2608
2609           fputc (separator, fp);
2610         }
2611
2612         char out_buf[HCBUFSIZ]; // scratch buffer
2613
2614         out_buf[0] = 0;
2615
2616         ascii_digest (out_buf, salt_pos, digest_pos);
2617
2618         fputs (out_buf, fp);
2619
2620         fputc ('\n', fp);
2621       }
2622       else
2623       {
2624         hccap_t hccap;
2625
2626         to_hccap_t (&hccap, salt_pos, digest_pos);
2627
2628         fwrite (&hccap, sizeof (hccap_t), 1, fp);
2629       }
2630     }
2631   }
2632
2633   fflush (fp);
2634
2635   fclose (fp);
2636
2637   unlink (old_hashfile);
2638
2639   if (rename (hashfile, old_hashfile) != 0)
2640   {
2641     log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2642
2643     exit (-1);
2644   }
2645
2646   unlink (hashfile);
2647
2648   if (rename (new_hashfile, hashfile) != 0)
2649   {
2650     log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2651
2652     exit (-1);
2653   }
2654
2655   unlink (old_hashfile);
2656 }
2657
2658 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2659 {
2660   uint num_elements = num;
2661
2662   device_param->kernel_params_buf32[30] = data.combs_mode;
2663   device_param->kernel_params_buf32[31] = num;
2664
2665   uint kernel_threads = device_param->kernel_threads;
2666
2667   while (num_elements % kernel_threads) num_elements++;
2668
2669   cl_kernel kernel = NULL;
2670
2671   switch (kern_run)
2672   {
2673     case KERN_RUN_1:    kernel = device_param->kernel1;     break;
2674     case KERN_RUN_12:   kernel = device_param->kernel12;    break;
2675     case KERN_RUN_2:    kernel = device_param->kernel2;     break;
2676     case KERN_RUN_23:   kernel = device_param->kernel23;    break;
2677     case KERN_RUN_3:    kernel = device_param->kernel3;     break;
2678   }
2679
2680   hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2681   hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2682   hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2683   hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2684   hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2685   hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2686   hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2687   hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2688   hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2689   hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2690   hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2691
2692   cl_event event;
2693
2694   if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2695   {
2696     const size_t global_work_size[3] = { num_elements,        32, 1 };
2697     const size_t local_work_size[3]  = { kernel_threads / 32, 32, 1 };
2698
2699     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2700   }
2701   else
2702   {
2703     if (kern_run == KERN_RUN_2)
2704     {
2705       if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2706       {
2707         num_elements = CEIL ((float) num_elements / device_param->vector_width);
2708       }
2709     }
2710
2711     while (num_elements % kernel_threads) num_elements++;
2712
2713     const size_t global_work_size[3] = { num_elements,   1, 1 };
2714     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2715
2716     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2717   }
2718
2719   hc_clFlush (data.ocl, device_param->command_queue);
2720
2721   if (device_param->nvidia_spin_damp)
2722   {
2723     if (data.devices_status == STATUS_RUNNING)
2724     {
2725       if (iteration < EXPECTED_ITERATIONS)
2726       {
2727         switch (kern_run)
2728         {
2729           case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2730           case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2731           case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2732         }
2733       }
2734     }
2735   }
2736
2737   hc_clWaitForEvents (data.ocl, 1, &event);
2738
2739   cl_ulong time_start;
2740   cl_ulong time_end;
2741
2742   hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2743   hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END,   sizeof (time_end),   &time_end,   NULL);
2744
2745   const double exec_us = (double) (time_end - time_start) / 1000;
2746
2747   if (data.devices_status == STATUS_RUNNING)
2748   {
2749     if (iteration < EXPECTED_ITERATIONS)
2750     {
2751       switch (kern_run)
2752       {
2753         case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2754         case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2755         case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2756       }
2757     }
2758   }
2759
2760   if (event_update)
2761   {
2762     uint exec_pos = device_param->exec_pos;
2763
2764     device_param->exec_ms[exec_pos] = exec_us / 1000;
2765
2766     exec_pos++;
2767
2768     if (exec_pos == EXEC_CACHE)
2769     {
2770       exec_pos = 0;
2771     }
2772
2773     device_param->exec_pos = exec_pos;
2774   }
2775
2776   hc_clReleaseEvent (data.ocl, event);
2777
2778   hc_clFinish (data.ocl, device_param->command_queue);
2779 }
2780
2781 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2782 {
2783   uint num_elements = num;
2784
2785   switch (kern_run)
2786   {
2787     case KERN_RUN_MP:   device_param->kernel_params_mp_buf32[8]   = num; break;
2788     case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2789     case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2790   }
2791
2792   // causes problems with special threads like in bcrypt
2793   // const uint kernel_threads = device_param->kernel_threads;
2794
2795   uint kernel_threads = device_param->kernel_threads;
2796
2797   while (num_elements % kernel_threads) num_elements++;
2798
2799   cl_kernel kernel = NULL;
2800
2801   switch (kern_run)
2802   {
2803     case KERN_RUN_MP:   kernel = device_param->kernel_mp;   break;
2804     case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2805     case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2806   }
2807
2808   switch (kern_run)
2809   {
2810     case KERN_RUN_MP:   hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2811                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp[4]);
2812                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp[5]);
2813                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp[6]);
2814                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp[7]);
2815                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp[8]);
2816                         break;
2817     case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2818                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_r[4]);
2819                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_r[5]);
2820                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_r[6]);
2821                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_r[7]);
2822                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_r[8]);
2823                         break;
2824     case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2825                         hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_l[4]);
2826                         hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_l[5]);
2827                         hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_l[6]);
2828                         hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_l[7]);
2829                         hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_l[8]);
2830                         hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint),  device_param->kernel_params_mp_l[9]);
2831                         break;
2832   }
2833
2834   const size_t global_work_size[3] = { num_elements,   1, 1 };
2835   const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2836
2837   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2838
2839   hc_clFlush (data.ocl, device_param->command_queue);
2840
2841   hc_clFinish (data.ocl, device_param->command_queue);
2842 }
2843
2844 static void run_kernel_tm (hc_device_param_t *device_param)
2845 {
2846   const uint num_elements = 1024; // fixed
2847
2848   uint kernel_threads = 32;
2849
2850   cl_kernel kernel = device_param->kernel_tm;
2851
2852   const size_t global_work_size[3] = { num_elements,    1, 1 };
2853   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
2854
2855   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2856
2857   hc_clFlush (data.ocl, device_param->command_queue);
2858
2859   hc_clFinish (data.ocl, device_param->command_queue);
2860 }
2861
2862 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2863 {
2864   uint num_elements = num;
2865
2866   device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2867   device_param->kernel_params_amp_buf32[6] = num_elements;
2868
2869   // causes problems with special threads like in bcrypt
2870   // const uint kernel_threads = device_param->kernel_threads;
2871
2872   uint kernel_threads = device_param->kernel_threads;
2873
2874   while (num_elements % kernel_threads) num_elements++;
2875
2876   cl_kernel kernel = device_param->kernel_amp;
2877
2878   hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2879   hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2880
2881   const size_t global_work_size[3] = { num_elements,    1, 1 };
2882   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
2883
2884   hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2885
2886   hc_clFlush (data.ocl, device_param->command_queue);
2887
2888   hc_clFinish (data.ocl, device_param->command_queue);
2889 }
2890
2891 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2892 {
2893   const u32 num16d = num / 16;
2894   const u32 num16m = num % 16;
2895
2896   if (num16d)
2897   {
2898     device_param->kernel_params_memset_buf32[1] = value;
2899     device_param->kernel_params_memset_buf32[2] = num16d;
2900
2901     uint kernel_threads = device_param->kernel_threads;
2902
2903     uint num_elements = num16d;
2904
2905     while (num_elements % kernel_threads) num_elements++;
2906
2907     cl_kernel kernel = device_param->kernel_memset;
2908
2909     hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem),  (void *) &buf);
2910     hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2911     hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2912
2913     const size_t global_work_size[3] = { num_elements,   1, 1 };
2914     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2915
2916     hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2917
2918     hc_clFlush (data.ocl, device_param->command_queue);
2919
2920     hc_clFinish (data.ocl, device_param->command_queue);
2921   }
2922
2923   if (num16m)
2924   {
2925     u32 tmp[4];
2926
2927     tmp[0] = value;
2928     tmp[1] = value;
2929     tmp[2] = value;
2930     tmp[3] = value;
2931
2932     hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2933   }
2934 }
2935
2936 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2937 {
2938   run_kernel_memset (device_param, buf, 0, size);
2939
2940   /*
2941   int rc = -1;
2942
2943   if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2944   {
2945     // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2946
2947     const cl_uchar zero = 0;
2948
2949     rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2950   }
2951
2952   if (rc != 0)
2953   {
2954     // NOTE: clEnqueueFillBuffer () always fails with -59
2955     //       IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2956     //       How's that possible, OpenCL 1.2 support is advertised??
2957     //       We need to workaround...
2958
2959     #define FILLSZ 0x100000
2960
2961     char *tmp = (char *) mymalloc (FILLSZ);
2962
2963     for (size_t i = 0; i < size; i += FILLSZ)
2964     {
2965       const size_t left = size - i;
2966
2967       const size_t fillsz = MIN (FILLSZ, left);
2968
2969       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2970     }
2971
2972     myfree (tmp);
2973   }
2974   */
2975 }
2976
2977 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)
2978 {
2979   if (data.hash_mode == 2000)
2980   {
2981     process_stdout (device_param, pws_cnt);
2982
2983     return;
2984   }
2985
2986   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2987   {
2988     if (attack_mode == ATTACK_MODE_BF)
2989     {
2990       if (opts_type & OPTS_TYPE_PT_BITSLICE)
2991       {
2992         const uint size_tm = 32 * sizeof (bs_word_t);
2993
2994         run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2995
2996         run_kernel_tm (device_param);
2997
2998         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);
2999       }
3000     }
3001
3002     if (highest_pw_len < 16)
3003     {
3004       run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3005     }
3006     else if (highest_pw_len < 32)
3007     {
3008       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3009     }
3010     else
3011     {
3012       run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3013     }
3014   }
3015   else
3016   {
3017     run_kernel_amp (device_param, pws_cnt);
3018
3019     run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3020
3021     if (opts_type & OPTS_TYPE_HOOK12)
3022     {
3023       run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3024
3025       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);
3026
3027       // do something with data
3028
3029       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);
3030     }
3031
3032     uint iter = salt_buf->salt_iter;
3033
3034     uint loop_step = device_param->kernel_loops;
3035
3036     for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3037     {
3038       uint loop_left = iter - loop_pos;
3039
3040       loop_left = MIN (loop_left, loop_step);
3041
3042       device_param->kernel_params_buf32[25] = loop_pos;
3043       device_param->kernel_params_buf32[26] = loop_left;
3044
3045       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3046
3047       if (data.devices_status == STATUS_CRACKED) break;
3048       if (data.devices_status == STATUS_ABORTED) break;
3049       if (data.devices_status == STATUS_QUIT)    break;
3050
3051       /**
3052        * speed
3053        */
3054
3055       const float iter_part = (float) (loop_pos + loop_left) / iter;
3056
3057       const u64 perf_sum_all = pws_cnt * iter_part;
3058
3059       double speed_ms;
3060
3061       hc_timer_get (device_param->timer_speed, speed_ms);
3062
3063       const u32 speed_pos = device_param->speed_pos;
3064
3065       device_param->speed_cnt[speed_pos] = perf_sum_all;
3066
3067       device_param->speed_ms[speed_pos] = speed_ms;
3068
3069       if (data.benchmark == 1)
3070       {
3071         if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3072       }
3073     }
3074
3075     if (opts_type & OPTS_TYPE_HOOK23)
3076     {
3077       run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3078
3079       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);
3080
3081       // do something with data
3082
3083       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);
3084     }
3085
3086     run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3087   }
3088 }
3089
3090 static int run_rule_engine (const int rule_len, const char *rule_buf)
3091 {
3092   if (rule_len == 0)
3093   {
3094     return 0;
3095   }
3096   else if (rule_len == 1)
3097   {
3098     if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3099   }
3100
3101   return 1;
3102 }
3103
3104 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3105 {
3106   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3107   {
3108     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);
3109   }
3110   else if (data.attack_kern == ATTACK_KERN_COMBI)
3111   {
3112     if (data.attack_mode == ATTACK_MODE_COMBI)
3113     {
3114       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3115       {
3116         if (data.opts_type & OPTS_TYPE_PT_ADD01)
3117         {
3118           for (u32 i = 0; i < pws_cnt; i++)
3119           {
3120             const u32 pw_len = device_param->pws_buf[i].pw_len;
3121
3122             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3123
3124             ptr[pw_len] = 0x01;
3125           }
3126         }
3127         else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3128         {
3129           for (u32 i = 0; i < pws_cnt; i++)
3130           {
3131             const u32 pw_len = device_param->pws_buf[i].pw_len;
3132
3133             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3134
3135             ptr[pw_len] = 0x80;
3136           }
3137         }
3138       }
3139     }
3140     else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3141     {
3142       if (data.opts_type & OPTS_TYPE_PT_ADD01)
3143       {
3144         for (u32 i = 0; i < pws_cnt; i++)
3145         {
3146           const u32 pw_len = device_param->pws_buf[i].pw_len;
3147
3148           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3149
3150           ptr[pw_len] = 0x01;
3151         }
3152       }
3153       else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3154       {
3155         for (u32 i = 0; i < pws_cnt; i++)
3156         {
3157           const u32 pw_len = device_param->pws_buf[i].pw_len;
3158
3159           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3160
3161           ptr[pw_len] = 0x80;
3162         }
3163       }
3164     }
3165
3166     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);
3167   }
3168   else if (data.attack_kern == ATTACK_KERN_BF)
3169   {
3170     const u64 off = device_param->words_off;
3171
3172     device_param->kernel_params_mp_l_buf64[3] = off;
3173
3174     run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3175   }
3176 }
3177
3178 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3179 {
3180   const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3181
3182   device_param->kernel_params_buf32[25] = 0;
3183   device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3184   device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3185
3186   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3187   {
3188     run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3189   }
3190   else
3191   {
3192     run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3193   }
3194
3195   const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3196
3197   return exec_ms_prev;
3198 }
3199
3200 static void autotune (hc_device_param_t *device_param)
3201 {
3202   const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3203
3204   const u32 kernel_accel_min = device_param->kernel_accel_min;
3205   const u32 kernel_accel_max = device_param->kernel_accel_max;
3206
3207   const u32 kernel_loops_min = device_param->kernel_loops_min;
3208   const u32 kernel_loops_max = device_param->kernel_loops_max;
3209
3210   u32 kernel_accel = kernel_accel_min;
3211   u32 kernel_loops = kernel_loops_min;
3212
3213   // in this case the user specified a fixed -u and -n on the commandline
3214   // no way to tune anything
3215   // but we need to run a few caching rounds
3216
3217   if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3218   {
3219     if (data.hash_mode != 2000)
3220     {
3221       try_run (device_param, kernel_accel, kernel_loops);
3222       try_run (device_param, kernel_accel, kernel_loops);
3223       try_run (device_param, kernel_accel, kernel_loops);
3224       try_run (device_param, kernel_accel, kernel_loops);
3225     }
3226
3227     device_param->kernel_accel = kernel_accel;
3228     device_param->kernel_loops = kernel_loops;
3229
3230     const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3231
3232     device_param->kernel_power = kernel_power;
3233
3234     return;
3235   }
3236
3237   // from here it's clear we are allowed to autotune
3238   // so let's init some fake words
3239
3240   const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3241
3242   if (data.attack_kern == ATTACK_KERN_BF)
3243   {
3244     run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3245   }
3246   else
3247   {
3248     for (u32 i = 0; i < kernel_power_max; i++)
3249     {
3250       device_param->pws_buf[i].i[0]   = i;
3251       device_param->pws_buf[i].i[1]   = 0x01234567;
3252       device_param->pws_buf[i].pw_len = 7 + (i & 7);
3253     }
3254
3255     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);
3256   }
3257
3258   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3259   {
3260     if (data.kernel_rules_cnt > 1)
3261     {
3262       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);
3263     }
3264   }
3265   else
3266   {
3267     run_kernel_amp (device_param, kernel_power_max);
3268   }
3269
3270   #define VERIFIER_CNT 1
3271
3272   // first find out highest kernel-loops that stays below target_ms
3273
3274   if (kernel_loops_min < kernel_loops_max)
3275   {
3276     for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3277     {
3278       double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3279
3280       for (int i = 0; i < VERIFIER_CNT; i++)
3281       {
3282         double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3283
3284         exec_ms = MIN (exec_ms, exec_ms_v);
3285       }
3286
3287       if (exec_ms < target_ms) break;
3288     }
3289   }
3290
3291   // now the same for kernel-accel but with the new kernel-loops from previous loop set
3292
3293   #define STEPS_CNT 10
3294
3295   if (kernel_accel_min < kernel_accel_max)
3296   {
3297     for (int i = 0; i < STEPS_CNT; i++)
3298     {
3299       const u32 kernel_accel_try = 1 << i;
3300
3301       if (kernel_accel_try < kernel_accel_min) continue;
3302       if (kernel_accel_try > kernel_accel_max) break;
3303
3304       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3305
3306       for (int i = 0; i < VERIFIER_CNT; i++)
3307       {
3308         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3309
3310         exec_ms = MIN (exec_ms, exec_ms_v);
3311       }
3312
3313       if (exec_ms > target_ms) break;
3314
3315       kernel_accel = kernel_accel_try;
3316     }
3317   }
3318
3319   // at this point we want to know the actual runtime for the following reason:
3320   // we need a reference for the balancing loop following up, and this
3321   // the balancing loop can have an effect that the creates a new opportunity, for example:
3322   //   if the target is 95 ms and the current runtime is 48ms the above loop
3323   //   stopped the execution because the previous exec_ms was > 95ms
3324   //   due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3325   //   and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3326
3327   double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3328
3329   for (int i = 0; i < VERIFIER_CNT; i++)
3330   {
3331     double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3332
3333     exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3334   }
3335
3336   u32 diff = kernel_loops - kernel_accel;
3337
3338   if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3339   {
3340     u32 kernel_accel_orig = kernel_accel;
3341     u32 kernel_loops_orig = kernel_loops;
3342
3343     for (u32 f = 1; f < 1024; f++)
3344     {
3345       const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3346       const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3347
3348       if (kernel_accel_try > kernel_accel_max) break;
3349       if (kernel_loops_try < kernel_loops_min) break;
3350
3351       u32 diff_new = kernel_loops_try - kernel_accel_try;
3352
3353       if (diff_new > diff) break;
3354
3355       diff_new = diff;
3356
3357       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3358
3359       for (int i = 0; i < VERIFIER_CNT; i++)
3360       {
3361         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3362
3363         exec_ms = MIN (exec_ms, exec_ms_v);
3364       }
3365
3366       if (exec_ms < exec_ms_pre_final)
3367       {
3368         exec_ms_pre_final = exec_ms;
3369
3370         kernel_accel = kernel_accel_try;
3371         kernel_loops = kernel_loops_try;
3372       }
3373     }
3374   }
3375
3376   const double exec_left = target_ms / exec_ms_pre_final;
3377
3378   const double accel_left = kernel_accel_max / kernel_accel;
3379
3380   const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3381
3382   if (exec_accel_min >= 1.0)
3383   {
3384     // this is safe to not overflow kernel_accel_max because of accel_left
3385
3386     kernel_accel = (double) kernel_accel * exec_accel_min;
3387   }
3388
3389   // reset them fake words
3390
3391   /*
3392   memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3393
3394   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);
3395   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);
3396   */
3397
3398   run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3399
3400   if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3401   {
3402     run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3403   }
3404
3405   // reset timer
3406
3407   device_param->exec_pos = 0;
3408
3409   memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3410
3411   memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3412   memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3413   memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3414
3415   // store
3416
3417   device_param->kernel_accel = kernel_accel;
3418   device_param->kernel_loops = kernel_loops;
3419
3420   const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3421
3422   device_param->kernel_power = kernel_power;
3423
3424   #ifdef DEBUG
3425
3426   if (data.quiet == 0)
3427   {
3428     clear_prompt ();
3429
3430     log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3431               "- Device #%u: autotuned kernel-loops to %u\n",
3432               device_param->device_id + 1, kernel_accel,
3433               device_param->device_id + 1, kernel_loops);
3434
3435     fprintf (stdout, "%s", PROMPT);
3436
3437     fflush (stdout);
3438   }
3439
3440   #endif
3441 }
3442
3443 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3444 {
3445   char *line_buf = (char *) mymalloc (HCBUFSIZ);
3446
3447   // init speed timer
3448
3449   uint speed_pos = device_param->speed_pos;
3450
3451   #ifdef _POSIX
3452   if (device_param->timer_speed.tv_sec == 0)
3453   {
3454     hc_timer_set (&device_param->timer_speed);
3455   }
3456   #endif
3457
3458   #ifdef _WIN
3459   if (device_param->timer_speed.QuadPart == 0)
3460   {
3461     hc_timer_set (&device_param->timer_speed);
3462   }
3463   #endif
3464
3465   // find higest password length, this is for optimization stuff
3466
3467   uint highest_pw_len = 0;
3468
3469   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3470   {
3471   }
3472   else if (data.attack_kern == ATTACK_KERN_COMBI)
3473   {
3474   }
3475   else if (data.attack_kern == ATTACK_KERN_BF)
3476   {
3477     highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3478                    + device_param->kernel_params_mp_l_buf32[5];
3479   }
3480
3481   // iteration type
3482
3483   uint innerloop_step = 0;
3484   uint innerloop_cnt  = 0;
3485
3486   if      (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)   innerloop_step = device_param->kernel_loops;
3487   else                                                      innerloop_step = 1;
3488
3489   if      (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt  = data.kernel_rules_cnt;
3490   else if (data.attack_kern == ATTACK_KERN_COMBI)    innerloop_cnt  = data.combs_cnt;
3491   else if (data.attack_kern == ATTACK_KERN_BF)       innerloop_cnt  = data.bfs_cnt;
3492
3493   // loop start: most outer loop = salt iteration, then innerloops (if multi)
3494
3495   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3496   {
3497     while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3498
3499     if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3500
3501     if (data.devices_status == STATUS_CRACKED) break;
3502     if (data.devices_status == STATUS_ABORTED) break;
3503     if (data.devices_status == STATUS_QUIT)    break;
3504     if (data.devices_status == STATUS_BYPASS)  break;
3505
3506     salt_t *salt_buf = &data.salts_buf[salt_pos];
3507
3508     device_param->kernel_params_buf32[24] = salt_pos;
3509     device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3510     device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3511
3512     FILE *combs_fp = device_param->combs_fp;
3513
3514     if (data.attack_mode == ATTACK_MODE_COMBI)
3515     {
3516       rewind (combs_fp);
3517     }
3518
3519     // innerloops
3520
3521     for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3522     {
3523       while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3524
3525       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3526
3527       if (data.devices_status == STATUS_CRACKED) break;
3528       if (data.devices_status == STATUS_ABORTED) break;
3529       if (data.devices_status == STATUS_QUIT)    break;
3530       if (data.devices_status == STATUS_BYPASS)  break;
3531
3532       uint fast_iteration = 0;
3533
3534       uint innerloop_left = innerloop_cnt - innerloop_pos;
3535
3536       if (innerloop_left > innerloop_step)
3537       {
3538         innerloop_left = innerloop_step;
3539
3540         fast_iteration = 1;
3541       }
3542
3543       device_param->innerloop_pos  = innerloop_pos;
3544       device_param->innerloop_left = innerloop_left;
3545
3546       device_param->kernel_params_buf32[27] = innerloop_left;
3547
3548       // i think we can get rid of this
3549       if (innerloop_left == 0)
3550       {
3551         puts ("bug, how should this happen????\n");
3552
3553         continue;
3554       }
3555
3556       if (data.salts_shown[salt_pos] == 1)
3557       {
3558         data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3559
3560         continue;
3561       }
3562
3563       // initialize amplifiers
3564
3565       if (data.attack_mode == ATTACK_MODE_COMBI)
3566       {
3567         uint i = 0;
3568
3569         while (i < innerloop_left)
3570         {
3571           if (feof (combs_fp)) break;
3572
3573           int line_len = fgetl (combs_fp, line_buf);
3574
3575           if (line_len >= PW_MAX1) continue;
3576
3577           line_len = convert_from_hex (line_buf, line_len);
3578
3579           char *line_buf_new = line_buf;
3580
3581           if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3582           {
3583             char rule_buf_out[BLOCK_SIZE] = { 0 };
3584
3585             int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3586
3587             if (rule_len_out < 0)
3588             {
3589               data.words_progress_rejected[salt_pos] += pws_cnt;
3590
3591               continue;
3592             }
3593
3594             line_len = rule_len_out;
3595
3596             line_buf_new = rule_buf_out;
3597           }
3598
3599           line_len = MIN (line_len, PW_DICTMAX);
3600
3601           u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3602
3603           memcpy (ptr, line_buf_new, line_len);
3604
3605           memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3606
3607           if (data.opts_type & OPTS_TYPE_PT_UPPER)
3608           {
3609             uppercase (ptr, line_len);
3610           }
3611
3612           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3613           {
3614             if (data.opts_type & OPTS_TYPE_PT_ADD80)
3615             {
3616               ptr[line_len] = 0x80;
3617             }
3618
3619             if (data.opts_type & OPTS_TYPE_PT_ADD01)
3620             {
3621               ptr[line_len] = 0x01;
3622             }
3623           }
3624
3625           device_param->combs_buf[i].pw_len = line_len;
3626
3627           i++;
3628         }
3629
3630         for (uint j = i; j < innerloop_left; j++)
3631         {
3632           device_param->combs_buf[j].i[0] = 0;
3633           device_param->combs_buf[j].i[1] = 0;
3634           device_param->combs_buf[j].i[2] = 0;
3635           device_param->combs_buf[j].i[3] = 0;
3636           device_param->combs_buf[j].i[4] = 0;
3637           device_param->combs_buf[j].i[5] = 0;
3638           device_param->combs_buf[j].i[6] = 0;
3639           device_param->combs_buf[j].i[7] = 0;
3640
3641           device_param->combs_buf[j].pw_len = 0;
3642         }
3643
3644         innerloop_left = i;
3645       }
3646       else if (data.attack_mode == ATTACK_MODE_BF)
3647       {
3648         u64 off = innerloop_pos;
3649
3650         device_param->kernel_params_mp_r_buf64[3] = off;
3651
3652         run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3653       }
3654       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3655       {
3656         u64 off = innerloop_pos;
3657
3658         device_param->kernel_params_mp_buf64[3] = off;
3659
3660         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3661       }
3662       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3663       {
3664         u64 off = innerloop_pos;
3665
3666         device_param->kernel_params_mp_buf64[3] = off;
3667
3668         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3669       }
3670
3671       // copy amplifiers
3672
3673       if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3674       {
3675         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);
3676       }
3677       else if (data.attack_mode == ATTACK_MODE_COMBI)
3678       {
3679         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);
3680       }
3681       else if (data.attack_mode == ATTACK_MODE_BF)
3682       {
3683         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);
3684       }
3685       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3686       {
3687         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);
3688       }
3689       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3690       {
3691         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);
3692       }
3693
3694       if (data.benchmark == 1)
3695       {
3696         hc_timer_set (&device_param->timer_speed);
3697       }
3698
3699       choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3700
3701       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3702
3703       if (data.devices_status == STATUS_CRACKED) break;
3704       if (data.devices_status == STATUS_ABORTED) break;
3705       if (data.devices_status == STATUS_QUIT)    break;
3706
3707       /**
3708        * result
3709        */
3710
3711       if (data.benchmark == 0)
3712       {
3713         check_cracked (device_param, salt_pos);
3714       }
3715
3716       /**
3717        * progress
3718        */
3719
3720       u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3721
3722       hc_thread_mutex_lock (mux_counter);
3723
3724       data.words_progress_done[salt_pos] += perf_sum_all;
3725
3726       hc_thread_mutex_unlock (mux_counter);
3727
3728       /**
3729        * speed
3730        */
3731
3732       double speed_ms;
3733
3734       hc_timer_get (device_param->timer_speed, speed_ms);
3735
3736       hc_timer_set (&device_param->timer_speed);
3737
3738       // current speed
3739
3740       //hc_thread_mutex_lock (mux_display);
3741
3742       device_param->speed_cnt[speed_pos] = perf_sum_all;
3743
3744       device_param->speed_ms[speed_pos] = speed_ms;
3745
3746       //hc_thread_mutex_unlock (mux_display);
3747
3748       speed_pos++;
3749
3750       if (speed_pos == SPEED_CACHE)
3751       {
3752         speed_pos = 0;
3753       }
3754
3755       /**
3756        * benchmark
3757        */
3758
3759       if (data.benchmark == 1) break;
3760     }
3761   }
3762
3763   device_param->speed_pos = speed_pos;
3764
3765   myfree (line_buf);
3766 }
3767
3768 static void load_segment (wl_data_t *wl_data, FILE *fd)
3769 {
3770   // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3771
3772   wl_data->pos = 0;
3773
3774   wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3775
3776   wl_data->buf[wl_data->cnt] = 0;
3777
3778   if (wl_data->cnt == 0) return;
3779
3780   if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3781
3782   while (!feof (fd))
3783   {
3784     if (wl_data->cnt == wl_data->avail)
3785     {
3786       wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3787
3788       wl_data->avail += wl_data->incr;
3789     }
3790
3791     const int c = fgetc (fd);
3792
3793     if (c == EOF) break;
3794
3795     wl_data->buf[wl_data->cnt] = (char) c;
3796
3797     wl_data->cnt++;
3798
3799     if (c == '\n') break;
3800   }
3801
3802   // ensure stream ends with a newline
3803
3804   if (wl_data->buf[wl_data->cnt - 1] != '\n')
3805   {
3806     wl_data->cnt++;
3807
3808     wl_data->buf[wl_data->cnt - 1] = '\n';
3809   }
3810
3811   return;
3812 }
3813
3814 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3815 {
3816   char *ptr = buf;
3817
3818   for (u32 i = 0; i < sz; i++, ptr++)
3819   {
3820     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3821
3822     if (i == 7)
3823     {
3824       *off = i;
3825       *len = i;
3826
3827       return;
3828     }
3829
3830     if (*ptr != '\n') continue;
3831
3832     *off = i + 1;
3833
3834     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3835
3836     *len = i;
3837
3838     return;
3839   }
3840
3841   *off = sz;
3842   *len = sz;
3843 }
3844
3845 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3846 {
3847   char *ptr = buf;
3848
3849   for (u32 i = 0; i < sz; i++, ptr++)
3850   {
3851     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3852
3853     if (*ptr != '\n') continue;
3854
3855     *off = i + 1;
3856
3857     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3858
3859     *len = i;
3860
3861     return;
3862   }
3863
3864   *off = sz;
3865   *len = sz;
3866 }
3867
3868 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3869 {
3870   char *ptr = buf;
3871
3872   for (u32 i = 0; i < sz; i++, ptr++)
3873   {
3874     if (*ptr != '\n') continue;
3875
3876     *off = i + 1;
3877
3878     if ((i > 0) && (buf[i - 1] == '\r')) i--;
3879
3880     *len = i;
3881
3882     return;
3883   }
3884
3885   *off = sz;
3886   *len = sz;
3887 }
3888
3889 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3890 {
3891   while (wl_data->pos < wl_data->cnt)
3892   {
3893     uint off;
3894     uint len;
3895
3896     char *ptr = wl_data->buf + wl_data->pos;
3897
3898     get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3899
3900     wl_data->pos += off;
3901
3902     if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3903     {
3904       char rule_buf_out[BLOCK_SIZE] = { 0 };
3905
3906       int rule_len_out = -1;
3907
3908       if (len < BLOCK_SIZE)
3909       {
3910         rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3911       }
3912
3913       if (rule_len_out < 0)
3914       {
3915         continue;
3916       }
3917
3918       if (rule_len_out > PW_MAX)
3919       {
3920         continue;
3921       }
3922     }
3923     else
3924     {
3925       if (len > PW_MAX)
3926       {
3927         continue;
3928       }
3929     }
3930
3931     *out_buf = ptr;
3932     *out_len = len;
3933
3934     return;
3935   }
3936
3937   if (feof (fd))
3938   {
3939     fprintf (stderr, "BUG feof()!!\n");
3940
3941     return;
3942   }
3943
3944   load_segment (wl_data, fd);
3945
3946   get_next_word (wl_data, fd, out_buf, out_len);
3947 }
3948
3949 #ifdef _POSIX
3950 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3951 #endif
3952
3953 #ifdef _WIN
3954 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3955 #endif
3956 {
3957   hc_signal (NULL);
3958
3959   dictstat_t d;
3960
3961   d.cnt = 0;
3962
3963   #ifdef _POSIX
3964   fstat (fileno (fd), &d.stat);
3965   #endif
3966
3967   #ifdef _WIN
3968   _fstat64 (fileno (fd), &d.stat);
3969   #endif
3970
3971   d.stat.st_mode    = 0;
3972   d.stat.st_nlink   = 0;
3973   d.stat.st_uid     = 0;
3974   d.stat.st_gid     = 0;
3975   d.stat.st_rdev    = 0;
3976   d.stat.st_atime   = 0;
3977
3978   #ifdef _POSIX
3979   d.stat.st_blksize = 0;
3980   d.stat.st_blocks  = 0;
3981   #endif
3982
3983   if (d.stat.st_size == 0) return 0;
3984
3985   dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3986
3987   if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3988   {
3989     if (d_cache)
3990     {
3991       u64 cnt = d_cache->cnt;
3992
3993       u64 keyspace = cnt;
3994
3995       if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3996       {
3997         keyspace *= data.kernel_rules_cnt;
3998       }
3999       else if (data.attack_kern == ATTACK_KERN_COMBI)
4000       {
4001         keyspace *= data.combs_cnt;
4002       }
4003
4004       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);
4005       if (data.quiet == 0) log_info ("");
4006
4007       hc_signal (sigHandler_default);
4008
4009       return (keyspace);
4010     }
4011   }
4012
4013   time_t now  = 0;
4014   time_t prev = 0;
4015
4016   u64 comp = 0;
4017   u64 cnt  = 0;
4018   u64 cnt2 = 0;
4019
4020   while (!feof (fd))
4021   {
4022     load_segment (wl_data, fd);
4023
4024     comp += wl_data->cnt;
4025
4026     u32 i = 0;
4027
4028     while (i < wl_data->cnt)
4029     {
4030       u32 len;
4031       u32 off;
4032
4033       get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4034
4035       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4036       {
4037         char rule_buf_out[BLOCK_SIZE] = { 0 };
4038
4039         int rule_len_out = -1;
4040
4041         if (len < BLOCK_SIZE)
4042         {
4043           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4044         }
4045
4046         if (rule_len_out < 0)
4047         {
4048           len = PW_MAX1;
4049         }
4050         else
4051         {
4052           len = rule_len_out;
4053         }
4054       }
4055
4056       if (len < PW_MAX1)
4057       {
4058         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4059         {
4060           cnt += data.kernel_rules_cnt;
4061         }
4062         else if (data.attack_kern == ATTACK_KERN_COMBI)
4063         {
4064           cnt += data.combs_cnt;
4065         }
4066
4067         d.cnt++;
4068       }
4069
4070       i += off;
4071
4072       cnt2++;
4073     }
4074
4075     time (&now);
4076
4077     if ((now - prev) == 0) continue;
4078
4079     float percent = (float) comp / (float) d.stat.st_size;
4080
4081     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);
4082
4083     time (&prev);
4084   }
4085
4086   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);
4087   if (data.quiet == 0) log_info ("");
4088
4089   lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4090
4091   hc_signal (sigHandler_default);
4092
4093   return (cnt);
4094 }
4095
4096 static void *thread_monitor (void *p)
4097 {
4098   uint runtime_check = 0;
4099   uint remove_check  = 0;
4100   uint status_check  = 0;
4101   uint restore_check = 0;
4102
4103   uint restore_left = data.restore_timer;
4104   uint remove_left  = data.remove_timer;
4105   uint status_left  = data.status_timer;
4106
4107   #ifdef HAVE_HWMON
4108   uint hwmon_check = 0;
4109
4110   int slowdown_warnings = 0;
4111
4112   // these variables are mainly used for fan control
4113
4114   int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4115
4116   // temperature controller "loopback" values
4117
4118   int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4119   int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4120
4121   int temp_threshold = 1; // degrees celcius
4122
4123   int fan_speed_min =  15; // in percentage
4124   int fan_speed_max = 100;
4125
4126   time_t last_temp_check_time;
4127   #endif // HAVE_HWMON
4128
4129   uint sleep_time = 1;
4130
4131   if (data.runtime)
4132   {
4133     runtime_check = 1;
4134   }
4135
4136   if (data.restore_timer)
4137   {
4138     restore_check = 1;
4139   }
4140
4141   if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4142   {
4143     remove_check = 1;
4144   }
4145
4146   if (data.status == 1)
4147   {
4148     status_check = 1;
4149   }
4150
4151   #ifdef HAVE_HWMON
4152   if (data.gpu_temp_disable == 0)
4153   {
4154     time (&last_temp_check_time);
4155
4156     hwmon_check = 1;
4157   }
4158   #endif
4159
4160   if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4161   {
4162     #ifdef HAVE_HWMON
4163     if (hwmon_check == 0)
4164     #endif
4165     return (p);
4166   }
4167
4168   while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4169   {
4170     hc_sleep (sleep_time);
4171
4172     if (data.devices_status != STATUS_RUNNING) continue;
4173
4174     #ifdef HAVE_HWMON
4175
4176     if (hwmon_check == 1)
4177     {
4178       hc_thread_mutex_lock (mux_adl);
4179
4180       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4181       {
4182         hc_device_param_t *device_param = &data.devices_param[device_id];
4183
4184         if (device_param->skipped) continue;
4185
4186         if (device_param->device_vendor_id == VENDOR_ID_NV)
4187         {
4188           if (data.hm_nvapi)
4189           {
4190             NV_GPU_PERF_POLICIES_INFO_PARAMS_V1   perfPolicies_info   = { 0 };
4191             NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4192
4193             perfPolicies_info.version   = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4194             perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4195
4196             hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4197
4198             perfPolicies_status.info_value = perfPolicies_info.info_value;
4199
4200             hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4201
4202             if (perfPolicies_status.throttle & 2)
4203             {
4204               if (slowdown_warnings < 3)
4205               {
4206                 if (data.quiet == 0) clear_prompt ();
4207
4208                 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4209
4210                 if (slowdown_warnings == 2)
4211                 {
4212                   log_info ("");
4213                 }
4214
4215                 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4216                 if (data.quiet == 0) fflush (stdout);
4217
4218                 slowdown_warnings++;
4219               }
4220             }
4221             else
4222             {
4223               slowdown_warnings = 0;
4224             }
4225           }
4226         }
4227       }
4228
4229       hc_thread_mutex_unlock (mux_adl);
4230     }
4231
4232     if (hwmon_check == 1)
4233     {
4234       hc_thread_mutex_lock (mux_adl);
4235
4236       time_t temp_check_time;
4237
4238       time (&temp_check_time);
4239
4240       uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4241
4242       if (Ta == 0) Ta = 1;
4243
4244       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4245       {
4246         hc_device_param_t *device_param = &data.devices_param[device_id];
4247
4248         if (device_param->skipped) continue;
4249
4250         if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4251
4252         const int temperature = hm_get_temperature_with_device_id (device_id);
4253
4254         if (temperature > (int) data.gpu_temp_abort)
4255         {
4256           log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4257
4258           if (data.devices_status != STATUS_QUIT) myabort ();
4259
4260           break;
4261         }
4262
4263         const int gpu_temp_retain = data.gpu_temp_retain;
4264
4265         if (gpu_temp_retain)
4266         {
4267           if (data.hm_device[device_id].fan_set_supported == 1)
4268           {
4269             int temp_cur = temperature;
4270
4271             int temp_diff_new = gpu_temp_retain - temp_cur;
4272
4273             temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4274
4275             // calculate Ta value (time difference in seconds between the last check and this check)
4276
4277             last_temp_check_time = temp_check_time;
4278
4279             float Kp = 1.8;
4280             float Ki = 0.005;
4281             float Kd = 6;
4282
4283             // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4284
4285             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);
4286
4287             if (abs (fan_diff_required) >= temp_threshold)
4288             {
4289               const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4290
4291               int fan_speed_level = fan_speed_cur;
4292
4293               if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4294
4295               int fan_speed_new = fan_speed_level - fan_diff_required;
4296
4297               if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4298               if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4299
4300               if (fan_speed_new != fan_speed_cur)
4301               {
4302                 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4303                 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4304
4305                 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4306                 {
4307                   if (device_param->device_vendor_id == VENDOR_ID_AMD)
4308                   {
4309                     hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4310                   }
4311                   else if (device_param->device_vendor_id == VENDOR_ID_NV)
4312                   {
4313                     #ifdef WIN
4314                     hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4315                     #endif
4316
4317                     #ifdef LINUX
4318                     hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4319                     #endif
4320                   }
4321
4322                   fan_speed_chgd[device_id] = 1;
4323                 }
4324
4325                 temp_diff_old[device_id] = temp_diff_new;
4326               }
4327             }
4328           }
4329         }
4330       }
4331
4332       hc_thread_mutex_unlock (mux_adl);
4333     }
4334     #endif // HAVE_HWMON
4335
4336     if (restore_check == 1)
4337     {
4338       restore_left--;
4339
4340       if (restore_left == 0)
4341       {
4342         if (data.restore_disable == 0) cycle_restore ();
4343
4344         restore_left = data.restore_timer;
4345       }
4346     }
4347
4348     if ((runtime_check == 1) && (data.runtime_start > 0))
4349     {
4350       time_t runtime_cur;
4351
4352       time (&runtime_cur);
4353
4354       int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4355
4356       if (runtime_left <= 0)
4357       {
4358         if (data.benchmark == 0)
4359         {
4360           if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4361         }
4362
4363         if (data.devices_status != STATUS_QUIT) myabort ();
4364       }
4365     }
4366
4367     if (remove_check == 1)
4368     {
4369       remove_left--;
4370
4371       if (remove_left == 0)
4372       {
4373         if (data.digests_saved != data.digests_done)
4374         {
4375           data.digests_saved = data.digests_done;
4376
4377           save_hash ();
4378         }
4379
4380         remove_left = data.remove_timer;
4381       }
4382     }
4383
4384     if (status_check == 1)
4385     {
4386       status_left--;
4387
4388       if (status_left == 0)
4389       {
4390         //hc_thread_mutex_lock (mux_display);
4391
4392         if (data.quiet == 0) clear_prompt ();
4393
4394         if (data.quiet == 0) log_info ("");
4395
4396         status_display ();
4397
4398         if (data.quiet == 0) log_info ("");
4399
4400         //hc_thread_mutex_unlock (mux_display);
4401
4402         status_left = data.status_timer;
4403       }
4404     }
4405   }
4406
4407   #ifdef HAVE_HWMON
4408   myfree (fan_speed_chgd);
4409
4410   myfree (temp_diff_old);
4411   myfree (temp_diff_sum);
4412   #endif
4413
4414   p = NULL;
4415
4416   return (p);
4417 }
4418
4419 static void *thread_outfile_remove (void *p)
4420 {
4421   // some hash-dependent constants
4422   char *outfile_dir = data.outfile_check_directory;
4423   uint dgst_size    = data.dgst_size;
4424   uint isSalted     = data.isSalted;
4425   uint esalt_size   = data.esalt_size;
4426   uint hash_mode    = data.hash_mode;
4427
4428   uint outfile_check_timer = data.outfile_check_timer;
4429
4430   char separator = data.separator;
4431
4432   // some hash-dependent functions
4433   int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4434   int (*parse_func) (char *, uint, hash_t *)         = data.parse_func;
4435
4436   // buffers
4437   hash_t hash_buf = { 0, 0, 0, 0, 0 };
4438
4439   hash_buf.digest = mymalloc (dgst_size);
4440
4441   if (isSalted)   hash_buf.salt =  (salt_t *) mymalloc (sizeof (salt_t));
4442
4443   if (esalt_size) hash_buf.esalt = (void   *) mymalloc (esalt_size);
4444
4445   uint digest_buf[64] = { 0 };
4446
4447   outfile_data_t *out_info = NULL;
4448
4449   char **out_files = NULL;
4450
4451   time_t folder_mtime = 0;
4452
4453   int  out_cnt = 0;
4454
4455   uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4456
4457   while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4458   {
4459     hc_sleep (1);
4460
4461     if (data.devices_status != STATUS_RUNNING) continue;
4462
4463     check_left--;
4464
4465     if (check_left == 0)
4466     {
4467       struct stat outfile_check_stat;
4468
4469       if (stat (outfile_dir, &outfile_check_stat) == 0)
4470       {
4471         uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4472
4473         if (is_dir == 1)
4474         {
4475           if (outfile_check_stat.st_mtime > folder_mtime)
4476           {
4477             char **out_files_new = scan_directory (outfile_dir);
4478
4479             int out_cnt_new = count_dictionaries (out_files_new);
4480
4481             outfile_data_t *out_info_new = NULL;
4482
4483             if (out_cnt_new > 0)
4484             {
4485               out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4486
4487               for (int i = 0; i < out_cnt_new; i++)
4488               {
4489                 out_info_new[i].file_name = out_files_new[i];
4490
4491                 // check if there are files that we have seen/checked before (and not changed)
4492
4493                 for (int j = 0; j < out_cnt; j++)
4494                 {
4495                   if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4496                   {
4497                     struct stat outfile_stat;
4498
4499                     if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4500                     {
4501                       if (outfile_stat.st_ctime == out_info[j].ctime)
4502                       {
4503                         out_info_new[i].ctime = out_info[j].ctime;
4504                         out_info_new[i].seek  = out_info[j].seek;
4505                       }
4506                     }
4507                   }
4508                 }
4509               }
4510             }
4511
4512             local_free (out_info);
4513             local_free (out_files);
4514
4515             out_files = out_files_new;
4516             out_cnt   = out_cnt_new;
4517             out_info  = out_info_new;
4518
4519             folder_mtime = outfile_check_stat.st_mtime;
4520           }
4521
4522           for (int j = 0; j < out_cnt; j++)
4523           {
4524             FILE *fp = fopen (out_info[j].file_name, "rb");
4525
4526             if (fp != NULL)
4527             {
4528               //hc_thread_mutex_lock (mux_display);
4529
4530               #ifdef _POSIX
4531               struct stat outfile_stat;
4532
4533               fstat (fileno (fp), &outfile_stat);
4534               #endif
4535
4536               #ifdef _WIN
4537               struct stat64 outfile_stat;
4538
4539               _fstat64 (fileno (fp), &outfile_stat);
4540               #endif
4541
4542               if (outfile_stat.st_ctime > out_info[j].ctime)
4543               {
4544                 out_info[j].ctime = outfile_stat.st_ctime;
4545                 out_info[j].seek  = 0;
4546               }
4547
4548               fseek (fp, out_info[j].seek, SEEK_SET);
4549
4550               char *line_buf = (char *) mymalloc (HCBUFSIZ);
4551
4552               while (!feof (fp))
4553               {
4554                 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4555
4556                 if (ptr == NULL) break;
4557
4558                 int line_len = strlen (line_buf);
4559
4560                 if (line_len <= 0) continue;
4561
4562                 int iter = MAX_CUT_TRIES;
4563
4564                 for (uint i = line_len - 1; i && iter; i--, line_len--)
4565                 {
4566                   if (line_buf[i] != separator) continue;
4567
4568                   int parser_status = PARSER_OK;
4569
4570                   if ((hash_mode != 2500) && (hash_mode != 6800))
4571                   {
4572                     parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4573                   }
4574
4575                   uint found = 0;
4576
4577                   if (parser_status == PARSER_OK)
4578                   {
4579                     for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4580                     {
4581                       if (data.salts_shown[salt_pos] == 1) continue;
4582
4583                       salt_t *salt_buf = &data.salts_buf[salt_pos];
4584
4585                       for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4586                       {
4587                         uint idx = salt_buf->digests_offset + digest_pos;
4588
4589                         if (data.digests_shown[idx] == 1) continue;
4590
4591                         uint cracked = 0;
4592
4593                         if (hash_mode == 6800)
4594                         {
4595                           if (i == salt_buf->salt_len)
4596                           {
4597                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4598                           }
4599                         }
4600                         else if (hash_mode == 2500)
4601                         {
4602                           // BSSID : MAC1 : MAC2 (:plain)
4603                           if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4604                           {
4605                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4606
4607                             if (!cracked) continue;
4608
4609                             // now compare MAC1 and MAC2 too, since we have this additional info
4610                             char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4611                             char *mac2_pos = mac1_pos + 12 + 1;
4612
4613                             wpa_t *wpas = (wpa_t *) data.esalts_buf;
4614                             wpa_t *wpa  = &wpas[salt_pos];
4615
4616                             // compare hex string(s) vs binary MAC address(es)
4617
4618                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4619                             {
4620                               if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4621                               {
4622                                 cracked = 0;
4623
4624                                 break;
4625                               }
4626                             }
4627
4628                             // early skip ;)
4629                             if (!cracked) continue;
4630
4631                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4632                             {
4633                               if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4634                               {
4635                                 cracked = 0;
4636
4637                                 break;
4638                               }
4639                             }
4640                           }
4641                         }
4642                         else
4643                         {
4644                           char *digests_buf_ptr = (char *) data.digests_buf;
4645
4646                           memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4647
4648                           cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4649                         }
4650
4651                         if (cracked == 1)
4652                         {
4653                           found = 1;
4654
4655                           data.digests_shown[idx] = 1;
4656
4657                           data.digests_done++;
4658
4659                           salt_buf->digests_done++;
4660
4661                           if (salt_buf->digests_done == salt_buf->digests_cnt)
4662                           {
4663                             data.salts_shown[salt_pos] = 1;
4664
4665                             data.salts_done++;
4666
4667                             if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4668                           }
4669                         }
4670                       }
4671
4672                       if (data.devices_status == STATUS_CRACKED) break;
4673                     }
4674                   }
4675
4676                   if (found) break;
4677
4678                   if (data.devices_status == STATUS_CRACKED) break;
4679
4680                   iter--;
4681                 }
4682
4683                 if (data.devices_status == STATUS_CRACKED) break;
4684               }
4685
4686               myfree (line_buf);
4687
4688               out_info[j].seek = ftell (fp);
4689
4690               //hc_thread_mutex_unlock (mux_display);
4691
4692               fclose (fp);
4693             }
4694           }
4695         }
4696       }
4697
4698       check_left = outfile_check_timer;
4699     }
4700   }
4701
4702   if (esalt_size) local_free (hash_buf.esalt);
4703
4704   if (isSalted)   local_free (hash_buf.salt);
4705
4706   local_free (hash_buf.digest);
4707
4708   local_free (out_info);
4709
4710   local_free (out_files);
4711
4712   p = NULL;
4713
4714   return (p);
4715 }
4716
4717 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4718 {
4719   //if (device_param->pws_cnt < device_param->kernel_power)
4720   //{
4721     pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4722
4723     u8 *ptr = (u8 *) pw->i;
4724
4725     memcpy (ptr, pw_buf, pw_len);
4726
4727     memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4728
4729     pw->pw_len = pw_len;
4730
4731     device_param->pws_cnt++;
4732   //}
4733   //else
4734   //{
4735   //  fprintf (stderr, "BUG pw_add()!!\n");
4736   //
4737   //  return;
4738   //}
4739 }
4740
4741 static void set_kernel_power_final (const u64 kernel_power_final)
4742 {
4743   if (data.quiet == 0)
4744   {
4745     clear_prompt ();
4746
4747     //log_info ("");
4748
4749     log_info ("INFO: approaching final keyspace, workload adjusted");
4750     log_info ("");
4751
4752     fprintf (stdout, "%s", PROMPT);
4753
4754     fflush (stdout);
4755   }
4756
4757   data.kernel_power_final = kernel_power_final;
4758 }
4759
4760 static u32 get_power (hc_device_param_t *device_param)
4761 {
4762   const u64 kernel_power_final = data.kernel_power_final;
4763
4764   if (kernel_power_final)
4765   {
4766     const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4767
4768     const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4769
4770     // work should be at least the hardware power available without any accelerator
4771
4772     const u64 work = MAX (words_left_device, device_param->hardware_power);
4773
4774     return work;
4775   }
4776
4777   return device_param->kernel_power;
4778 }
4779
4780 static uint get_work (hc_device_param_t *device_param, const u64 max)
4781 {
4782   hc_thread_mutex_lock (mux_dispatcher);
4783
4784   const u64 words_cur  = data.words_cur;
4785   const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4786
4787   device_param->words_off = words_cur;
4788
4789   const u64 kernel_power_all = data.kernel_power_all;
4790
4791   const u64 words_left = words_base - words_cur;
4792
4793   if (words_left < kernel_power_all)
4794   {
4795     if (data.kernel_power_final == 0)
4796     {
4797       set_kernel_power_final (words_left);
4798     }
4799   }
4800
4801   const u32 kernel_power = get_power (device_param);
4802
4803   uint work = MIN (words_left, kernel_power);
4804
4805   work = MIN (work, max);
4806
4807   data.words_cur += work;
4808
4809   hc_thread_mutex_unlock (mux_dispatcher);
4810
4811   return work;
4812 }
4813
4814 static void *thread_autotune (void *p)
4815 {
4816   hc_device_param_t *device_param = (hc_device_param_t *) p;
4817
4818   if (device_param->skipped) return NULL;
4819
4820   autotune (device_param);
4821
4822   return NULL;
4823 }
4824
4825 static void *thread_calc_stdin (void *p)
4826 {
4827   hc_device_param_t *device_param = (hc_device_param_t *) p;
4828
4829   if (device_param->skipped) return NULL;
4830
4831   char *buf = (char *) mymalloc (HCBUFSIZ);
4832
4833   const uint attack_kern = data.attack_kern;
4834
4835   while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4836   {
4837     hc_thread_mutex_lock (mux_dispatcher);
4838
4839     if (feof (stdin) != 0)
4840     {
4841       hc_thread_mutex_unlock (mux_dispatcher);
4842
4843       break;
4844     }
4845
4846     uint words_cur = 0;
4847
4848     while (words_cur < device_param->kernel_power)
4849     {
4850       char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4851
4852       if (line_buf == NULL) break;
4853
4854       uint line_len = in_superchop (line_buf);
4855
4856       line_len = convert_from_hex (line_buf, line_len);
4857
4858       // post-process rule engine
4859
4860       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4861       {
4862         char rule_buf_out[BLOCK_SIZE] = { 0 };
4863
4864         int rule_len_out = -1;
4865
4866         if (line_len < BLOCK_SIZE)
4867         {
4868           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4869         }
4870
4871         if (rule_len_out < 0) continue;
4872
4873         line_buf = rule_buf_out;
4874         line_len = rule_len_out;
4875       }
4876
4877       if (line_len > PW_MAX)
4878       {
4879         continue;
4880       }
4881
4882       // hmm that's always the case, or?
4883
4884       if (attack_kern == ATTACK_KERN_STRAIGHT)
4885       {
4886         if ((line_len < data.pw_min) || (line_len > data.pw_max))
4887         {
4888           hc_thread_mutex_lock (mux_counter);
4889
4890           for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4891           {
4892             data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4893           }
4894
4895           hc_thread_mutex_unlock (mux_counter);
4896
4897           continue;
4898         }
4899       }
4900
4901       pw_add (device_param, (u8 *) line_buf, line_len);
4902
4903       words_cur++;
4904
4905       if (data.devices_status == STATUS_CRACKED) break;
4906       if (data.devices_status == STATUS_ABORTED) break;
4907       if (data.devices_status == STATUS_QUIT)    break;
4908       if (data.devices_status == STATUS_BYPASS)  break;
4909     }
4910
4911     hc_thread_mutex_unlock (mux_dispatcher);
4912
4913     if (data.devices_status == STATUS_CRACKED) break;
4914     if (data.devices_status == STATUS_ABORTED) break;
4915     if (data.devices_status == STATUS_QUIT)    break;
4916     if (data.devices_status == STATUS_BYPASS)  break;
4917
4918     // flush
4919
4920     const uint pws_cnt = device_param->pws_cnt;
4921
4922     if (pws_cnt)
4923     {
4924       run_copy (device_param, pws_cnt);
4925
4926       run_cracker (device_param, pws_cnt);
4927
4928       device_param->pws_cnt = 0;
4929
4930       /*
4931       still required?
4932       if (attack_kern == ATTACK_KERN_STRAIGHT)
4933       {
4934         run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4935       }
4936       else if (attack_kern == ATTACK_KERN_COMBI)
4937       {
4938         run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4939       }
4940       */
4941     }
4942   }
4943
4944   device_param->kernel_accel = 0;
4945   device_param->kernel_loops = 0;
4946
4947   myfree (buf);
4948
4949   return NULL;
4950 }
4951
4952 static void *thread_calc (void *p)
4953 {
4954   hc_device_param_t *device_param = (hc_device_param_t *) p;
4955
4956   if (device_param->skipped) return NULL;
4957
4958   const uint attack_mode = data.attack_mode;
4959   const uint attack_kern = data.attack_kern;
4960
4961   if (attack_mode == ATTACK_MODE_BF)
4962   {
4963     while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4964     {
4965       const uint work = get_work (device_param, -1);
4966
4967       if (work == 0) break;
4968
4969       const u64 words_off = device_param->words_off;
4970       const u64 words_fin = words_off + work;
4971
4972       const uint pws_cnt = work;
4973
4974       device_param->pws_cnt = pws_cnt;
4975
4976       if (pws_cnt)
4977       {
4978         run_copy (device_param, pws_cnt);
4979
4980         run_cracker (device_param, pws_cnt);
4981
4982         device_param->pws_cnt = 0;
4983
4984         /*
4985         still required?
4986         run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4987         */
4988       }
4989
4990       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4991
4992       if (data.devices_status == STATUS_CRACKED) break;
4993       if (data.devices_status == STATUS_ABORTED) break;
4994       if (data.devices_status == STATUS_QUIT)    break;
4995       if (data.devices_status == STATUS_BYPASS)  break;
4996
4997       if (data.benchmark == 1) break;
4998
4999       device_param->words_done = words_fin;
5000     }
5001   }
5002   else
5003   {
5004     const uint segment_size = data.segment_size;
5005
5006     char *dictfile = data.dictfile;
5007
5008     if (attack_mode == ATTACK_MODE_COMBI)
5009     {
5010       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5011       {
5012         dictfile = data.dictfile2;
5013       }
5014     }
5015
5016     FILE *fd = fopen (dictfile, "rb");
5017
5018     if (fd == NULL)
5019     {
5020       log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5021
5022       return NULL;
5023     }
5024
5025     if (attack_mode == ATTACK_MODE_COMBI)
5026     {
5027       const uint combs_mode = data.combs_mode;
5028
5029       if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5030       {
5031         const char *dictfilec = data.dictfile2;
5032
5033         FILE *combs_fp = fopen (dictfilec, "rb");
5034
5035         if (combs_fp == NULL)
5036         {
5037           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5038
5039           fclose (fd);
5040
5041           return NULL;
5042         }
5043
5044         device_param->combs_fp = combs_fp;
5045       }
5046       else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5047       {
5048         const char *dictfilec = data.dictfile;
5049
5050         FILE *combs_fp = fopen (dictfilec, "rb");
5051
5052         if (combs_fp == NULL)
5053         {
5054           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5055
5056           fclose (fd);
5057
5058           return NULL;
5059         }
5060
5061         device_param->combs_fp = combs_fp;
5062       }
5063     }
5064
5065     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5066
5067     wl_data->buf   = (char *) mymalloc (segment_size);
5068     wl_data->avail = segment_size;
5069     wl_data->incr  = segment_size;
5070     wl_data->cnt   = 0;
5071     wl_data->pos   = 0;
5072
5073     u64 words_cur = 0;
5074
5075     while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5076     {
5077       u64 words_off = 0;
5078       u64 words_fin = 0;
5079
5080       u64 max = -1;
5081
5082       while (max)
5083       {
5084         const uint work = get_work (device_param, max);
5085
5086         if (work == 0) break;
5087
5088         max = 0;
5089
5090         words_off = device_param->words_off;
5091         words_fin = words_off + work;
5092
5093         char *line_buf;
5094         uint  line_len;
5095
5096         for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5097
5098         for ( ; words_cur < words_fin; words_cur++)
5099         {
5100           get_next_word (wl_data, fd, &line_buf, &line_len);
5101
5102           line_len = convert_from_hex (line_buf, line_len);
5103
5104           // post-process rule engine
5105
5106           if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5107           {
5108             char rule_buf_out[BLOCK_SIZE] = { 0 };
5109
5110             int rule_len_out = -1;
5111
5112             if (line_len < BLOCK_SIZE)
5113             {
5114               rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5115             }
5116
5117             if (rule_len_out < 0) continue;
5118
5119             line_buf = rule_buf_out;
5120             line_len = rule_len_out;
5121           }
5122
5123           if (attack_kern == ATTACK_KERN_STRAIGHT)
5124           {
5125             if ((line_len < data.pw_min) || (line_len > data.pw_max))
5126             {
5127               max++;
5128
5129               hc_thread_mutex_lock (mux_counter);
5130
5131               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5132               {
5133                 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5134               }
5135
5136               hc_thread_mutex_unlock (mux_counter);
5137
5138               continue;
5139             }
5140           }
5141           else if (attack_kern == ATTACK_KERN_COMBI)
5142           {
5143             // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5144             // since we still need to combine the plains
5145
5146             if (line_len > data.pw_max)
5147             {
5148               max++;
5149
5150               hc_thread_mutex_lock (mux_counter);
5151
5152               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5153               {
5154                 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5155               }
5156
5157               hc_thread_mutex_unlock (mux_counter);
5158
5159               continue;
5160             }
5161           }
5162
5163           pw_add (device_param, (u8 *) line_buf, line_len);
5164
5165           if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5166
5167           if (data.devices_status == STATUS_CRACKED) break;
5168           if (data.devices_status == STATUS_ABORTED) break;
5169           if (data.devices_status == STATUS_QUIT)    break;
5170           if (data.devices_status == STATUS_BYPASS)  break;
5171         }
5172
5173         if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5174
5175         if (data.devices_status == STATUS_CRACKED) break;
5176         if (data.devices_status == STATUS_ABORTED) break;
5177         if (data.devices_status == STATUS_QUIT)    break;
5178         if (data.devices_status == STATUS_BYPASS)  break;
5179       }
5180
5181       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5182
5183       if (data.devices_status == STATUS_CRACKED) break;
5184       if (data.devices_status == STATUS_ABORTED) break;
5185       if (data.devices_status == STATUS_QUIT)    break;
5186       if (data.devices_status == STATUS_BYPASS)  break;
5187
5188       //
5189       // flush
5190       //
5191
5192       const uint pws_cnt = device_param->pws_cnt;
5193
5194       if (pws_cnt)
5195       {
5196         run_copy (device_param, pws_cnt);
5197
5198         run_cracker (device_param, pws_cnt);
5199
5200         device_param->pws_cnt = 0;
5201
5202         /*
5203         still required?
5204         if (attack_kern == ATTACK_KERN_STRAIGHT)
5205         {
5206           run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5207         }
5208         else if (attack_kern == ATTACK_KERN_COMBI)
5209         {
5210           run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5211         }
5212         */
5213       }
5214
5215       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5216
5217       if (data.devices_status == STATUS_CRACKED) break;
5218       if (data.devices_status == STATUS_ABORTED) break;
5219       if (data.devices_status == STATUS_QUIT)    break;
5220       if (data.devices_status == STATUS_BYPASS)  break;
5221
5222       if (words_fin == 0) break;
5223
5224       device_param->words_done = words_fin;
5225     }
5226
5227     if (attack_mode == ATTACK_MODE_COMBI)
5228     {
5229       fclose (device_param->combs_fp);
5230     }
5231
5232     free (wl_data->buf);
5233     free (wl_data);
5234
5235     fclose (fd);
5236   }
5237
5238   device_param->kernel_accel = 0;
5239   device_param->kernel_loops = 0;
5240
5241   return NULL;
5242 }
5243
5244 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5245 {
5246   if (!device_param)
5247   {
5248     log_error ("ERROR: %s : Invalid argument", __func__);
5249
5250     exit (-1);
5251   }
5252
5253   salt_t *salt_buf = &data.salts_buf[salt_pos];
5254
5255   device_param->kernel_params_buf32[24] = salt_pos;
5256   device_param->kernel_params_buf32[27] = 1;
5257   device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5258   device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5259   device_param->kernel_params_buf32[30] = 0;
5260   device_param->kernel_params_buf32[31] = 1;
5261
5262   char *dictfile_old = data.dictfile;
5263
5264   const char *weak_hash_check = "weak-hash-check";
5265
5266   data.dictfile = (char *) weak_hash_check;
5267
5268   uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5269
5270   data.kernel_rules_buf[0].cmds[0] = 0;
5271
5272   /**
5273    * run the kernel
5274    */
5275
5276   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5277   {
5278     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5279   }
5280   else
5281   {
5282     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5283
5284     uint loop_step = 16;
5285
5286     const uint iter = salt_buf->salt_iter;
5287
5288     for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5289     {
5290       uint loop_left = iter - loop_pos;
5291
5292       loop_left = MIN (loop_left, loop_step);
5293
5294       device_param->kernel_params_buf32[25] = loop_pos;
5295       device_param->kernel_params_buf32[26] = loop_left;
5296
5297       run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5298     }
5299
5300     run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5301   }
5302
5303   /**
5304    * result
5305    */
5306
5307   check_cracked (device_param, salt_pos);
5308
5309   /**
5310    * cleanup
5311    */
5312
5313   device_param->kernel_params_buf32[24] = 0;
5314   device_param->kernel_params_buf32[25] = 0;
5315   device_param->kernel_params_buf32[26] = 0;
5316   device_param->kernel_params_buf32[27] = 0;
5317   device_param->kernel_params_buf32[28] = 0;
5318   device_param->kernel_params_buf32[29] = 0;
5319   device_param->kernel_params_buf32[30] = 0;
5320   device_param->kernel_params_buf32[31] = 0;
5321
5322   data.dictfile = dictfile_old;
5323
5324   data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5325 }
5326
5327 // hlfmt hashcat
5328
5329 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5330 {
5331   if (data.username == 0)
5332   {
5333     *hashbuf_pos = line_buf;
5334     *hashbuf_len = line_len;
5335   }
5336   else
5337   {
5338     char *pos = line_buf;
5339     int   len = line_len;
5340
5341     for (int i = 0; i < line_len; i++, pos++, len--)
5342     {
5343       if (line_buf[i] == data.separator)
5344       {
5345         pos++;
5346
5347         len--;
5348
5349         break;
5350       }
5351     }
5352
5353     *hashbuf_pos = pos;
5354     *hashbuf_len = len;
5355   }
5356 }
5357
5358 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5359 {
5360   char *pos = NULL;
5361   int   len = 0;
5362
5363   int sep_cnt = 0;
5364
5365   for (int i = 0; i < line_len; i++)
5366   {
5367     if (line_buf[i] == data.separator)
5368     {
5369       sep_cnt++;
5370
5371       continue;
5372     }
5373
5374     if (sep_cnt == 0)
5375     {
5376       if (pos == NULL) pos = line_buf + i;
5377
5378       len++;
5379     }
5380   }
5381
5382   *userbuf_pos = pos;
5383   *userbuf_len = len;
5384 }
5385
5386 // hlfmt pwdump
5387
5388 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5389 {
5390   int sep_cnt = 0;
5391
5392   int sep2_len = 0;
5393   int sep3_len = 0;
5394
5395   for (int i = 0; i < line_len; i++)
5396   {
5397     if (line_buf[i] == ':')
5398     {
5399       sep_cnt++;
5400
5401       continue;
5402     }
5403
5404     if (sep_cnt == 2) sep2_len++;
5405     if (sep_cnt == 3) sep3_len++;
5406   }
5407
5408   if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5409
5410   return 0;
5411 }
5412
5413 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5414 {
5415   char *pos = NULL;
5416   int   len = 0;
5417
5418   int sep_cnt = 0;
5419
5420   for (int i = 0; i < line_len; i++)
5421   {
5422     if (line_buf[i] == ':')
5423     {
5424       sep_cnt++;
5425
5426       continue;
5427     }
5428
5429     if (data.hash_mode == 1000)
5430     {
5431       if (sep_cnt == 3)
5432       {
5433         if (pos == NULL) pos = line_buf + i;
5434
5435         len++;
5436       }
5437     }
5438     else if (data.hash_mode == 3000)
5439     {
5440       if (sep_cnt == 2)
5441       {
5442         if (pos == NULL) pos = line_buf + i;
5443
5444         len++;
5445       }
5446     }
5447   }
5448
5449   *hashbuf_pos = pos;
5450   *hashbuf_len = len;
5451 }
5452
5453 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5454 {
5455   char *pos = NULL;
5456   int   len = 0;
5457
5458   int sep_cnt = 0;
5459
5460   for (int i = 0; i < line_len; i++)
5461   {
5462     if (line_buf[i] == ':')
5463     {
5464       sep_cnt++;
5465
5466       continue;
5467     }
5468
5469     if (sep_cnt == 0)
5470     {
5471       if (pos == NULL) pos = line_buf + i;
5472
5473       len++;
5474     }
5475   }
5476
5477   *userbuf_pos = pos;
5478   *userbuf_len = len;
5479 }
5480
5481 // hlfmt passwd
5482
5483 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5484 {
5485   int sep_cnt = 0;
5486
5487   char sep5_first = 0;
5488   char sep6_first = 0;
5489
5490   for (int i = 0; i < line_len; i++)
5491   {
5492     if (line_buf[i] == ':')
5493     {
5494       sep_cnt++;
5495
5496       continue;
5497     }
5498
5499     if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5500     if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5501   }
5502
5503   if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5504
5505   return 0;
5506 }
5507
5508 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5509 {
5510   char *pos = NULL;
5511   int   len = 0;
5512
5513   int sep_cnt = 0;
5514
5515   for (int i = 0; i < line_len; i++)
5516   {
5517     if (line_buf[i] == ':')
5518     {
5519       sep_cnt++;
5520
5521       continue;
5522     }
5523
5524     if (sep_cnt == 1)
5525     {
5526       if (pos == NULL) pos = line_buf + i;
5527
5528       len++;
5529     }
5530   }
5531
5532   *hashbuf_pos = pos;
5533   *hashbuf_len = len;
5534 }
5535
5536 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5537 {
5538   char *pos = NULL;
5539   int   len = 0;
5540
5541   int sep_cnt = 0;
5542
5543   for (int i = 0; i < line_len; i++)
5544   {
5545     if (line_buf[i] == ':')
5546     {
5547       sep_cnt++;
5548
5549       continue;
5550     }
5551
5552     if (sep_cnt == 0)
5553     {
5554       if (pos == NULL) pos = line_buf + i;
5555
5556       len++;
5557     }
5558   }
5559
5560   *userbuf_pos = pos;
5561   *userbuf_len = len;
5562 }
5563
5564 // hlfmt shadow
5565
5566 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5567 {
5568   int sep_cnt = 0;
5569
5570   for (int i = 0; i < line_len; i++)
5571   {
5572     if (line_buf[i] == ':') sep_cnt++;
5573   }
5574
5575   if (sep_cnt == 8) return 1;
5576
5577   return 0;
5578 }
5579
5580 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5581 {
5582   hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5583 }
5584
5585 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5586 {
5587   hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5588 }
5589
5590 // hlfmt main
5591
5592 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5593 {
5594   switch (hashfile_format)
5595   {
5596     case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5597     case HLFMT_PWDUMP:  hlfmt_hash_pwdump  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5598     case HLFMT_PASSWD:  hlfmt_hash_passwd  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5599     case HLFMT_SHADOW:  hlfmt_hash_shadow  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5600   }
5601 }
5602
5603 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5604 {
5605   switch (hashfile_format)
5606   {
5607     case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5608     case HLFMT_PWDUMP:  hlfmt_user_pwdump  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5609     case HLFMT_PASSWD:  hlfmt_user_passwd  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5610     case HLFMT_SHADOW:  hlfmt_user_shadow  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5611   }
5612 }
5613
5614 char *strhlfmt (const uint hashfile_format)
5615 {
5616   switch (hashfile_format)
5617   {
5618     case HLFMT_HASHCAT:  return ((char *) HLFMT_TEXT_HASHCAT);  break;
5619     case HLFMT_PWDUMP:   return ((char *) HLFMT_TEXT_PWDUMP);   break;
5620     case HLFMT_PASSWD:   return ((char *) HLFMT_TEXT_PASSWD);   break;
5621     case HLFMT_SHADOW:   return ((char *) HLFMT_TEXT_SHADOW);   break;
5622     case HLFMT_DCC:      return ((char *) HLFMT_TEXT_DCC);      break;
5623     case HLFMT_DCC2:     return ((char *) HLFMT_TEXT_DCC2);     break;
5624     case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5625     case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5626     case HLFMT_NSLDAP:   return ((char *) HLFMT_TEXT_NSLDAP);   break;
5627     case HLFMT_NSLDAPS:  return ((char *) HLFMT_TEXT_NSLDAPS);  break;
5628   }
5629
5630   return ((char *) "Unknown");
5631 }
5632
5633 static uint hlfmt_detect (FILE *fp, uint max_check)
5634 {
5635   // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5636
5637   if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5638   if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5639
5640   uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5641
5642   uint num_check = 0;
5643
5644   char *line_buf = (char *) mymalloc (HCBUFSIZ);
5645
5646   while (!feof (fp))
5647   {
5648     int line_len = fgetl (fp, line_buf);
5649
5650     if (line_len == 0) continue;
5651
5652     if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5653     if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5654     if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5655
5656     if (num_check == max_check) break;
5657
5658     num_check++;
5659   }
5660
5661   myfree (line_buf);
5662
5663   uint hashlist_format = HLFMT_HASHCAT;
5664
5665   for (int i = 1; i < HLFMTS_CNT; i++)
5666   {
5667     if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5668
5669     hashlist_format = i;
5670   }
5671
5672   free (formats_cnt);
5673
5674   return hashlist_format;
5675 }
5676
5677 /**
5678  * some further helper function
5679  */
5680
5681 // wrapper around mymalloc for ADL
5682
5683 #if defined(HAVE_HWMON)
5684 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5685 {
5686   return mymalloc (iSize);
5687 }
5688 #endif
5689
5690 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)
5691 {
5692   u64 collisions = 0;
5693
5694   const uint dgst_pos0 = data.dgst_pos0;
5695   const uint dgst_pos1 = data.dgst_pos1;
5696   const uint dgst_pos2 = data.dgst_pos2;
5697   const uint dgst_pos3 = data.dgst_pos3;
5698
5699   memset (bitmap_a, 0, bitmap_size);
5700   memset (bitmap_b, 0, bitmap_size);
5701   memset (bitmap_c, 0, bitmap_size);
5702   memset (bitmap_d, 0, bitmap_size);
5703
5704   for (uint i = 0; i < digests_cnt; i++)
5705   {
5706     uint *digest_ptr = (uint *) digests_buf_ptr;
5707
5708     digests_buf_ptr += dgst_size;
5709
5710     const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5711     const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5712     const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5713     const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5714
5715     const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5716     const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5717     const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5718     const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5719
5720     if (bitmap_a[idx0] & val0) collisions++;
5721     if (bitmap_b[idx1] & val1) collisions++;
5722     if (bitmap_c[idx2] & val2) collisions++;
5723     if (bitmap_d[idx3] & val3) collisions++;
5724
5725     bitmap_a[idx0] |= val0;
5726     bitmap_b[idx1] |= val1;
5727     bitmap_c[idx2] |= val2;
5728     bitmap_d[idx3] |= val3;
5729
5730     if (collisions >= collisions_max) return 0x7fffffff;
5731   }
5732
5733   return collisions;
5734 }
5735
5736 /**
5737  * main
5738  */
5739
5740 #ifdef WIN
5741 void SetConsoleWindowSize (const int x)
5742 {
5743   HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5744
5745   if (h == INVALID_HANDLE_VALUE) return;
5746
5747   CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5748
5749   if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5750
5751   SMALL_RECT *sr = &bufferInfo.srWindow;
5752
5753   sr->Right = MAX (sr->Right, x - 1);
5754
5755   COORD co;
5756
5757   co.X = sr->Right + 1;
5758   co.Y = 9999;
5759
5760   if (!SetConsoleScreenBufferSize (h, co)) return;
5761
5762   if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5763 }
5764 #endif
5765
5766 int main (int argc, char **argv)
5767 {
5768   #ifdef WIN
5769   SetConsoleWindowSize (132);
5770   #endif
5771
5772   /**
5773    * To help users a bit
5774    */
5775
5776   char *compute = getenv ("COMPUTE");
5777
5778   if (compute)
5779   {
5780     static char display[100];
5781
5782     snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5783
5784     putenv (display);
5785   }
5786   else
5787   {
5788     if (getenv ("DISPLAY") == NULL)
5789       putenv ((char *) "DISPLAY=:0");
5790   }
5791
5792   if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5793     putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5794
5795   if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5796     putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5797
5798   if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5799     putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5800
5801   if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5802     putenv ((char *) "CUDA_CACHE_DISABLE=1");
5803
5804   if (getenv ("POCL_KERNEL_CACHE") == NULL)
5805     putenv ((char *) "POCL_KERNEL_CACHE=0");
5806
5807   umask (077);
5808
5809   /**
5810    * Real init
5811    */
5812
5813   memset (&data, 0, sizeof (hc_global_data_t));
5814
5815   time_t proc_start;
5816
5817   time (&proc_start);
5818
5819   data.proc_start = proc_start;
5820
5821   int    myargc = argc;
5822   char **myargv = argv;
5823
5824   hc_thread_mutex_init (mux_dispatcher);
5825   hc_thread_mutex_init (mux_counter);
5826   hc_thread_mutex_init (mux_display);
5827   hc_thread_mutex_init (mux_adl);
5828
5829   /**
5830    * commandline parameters
5831    */
5832
5833   uint  usage                     = USAGE;
5834   uint  version                   = VERSION;
5835   uint  quiet                     = QUIET;
5836   uint  benchmark                 = BENCHMARK;
5837   uint  stdout_flag               = STDOUT_FLAG;
5838   uint  show                      = SHOW;
5839   uint  left                      = LEFT;
5840   uint  username                  = USERNAME;
5841   uint  remove                    = REMOVE;
5842   uint  remove_timer              = REMOVE_TIMER;
5843   u64   skip                      = SKIP;
5844   u64   limit                     = LIMIT;
5845   uint  keyspace                  = KEYSPACE;
5846   uint  potfile_disable           = POTFILE_DISABLE;
5847   char *potfile_path              = NULL;
5848   uint  debug_mode                = DEBUG_MODE;
5849   char *debug_file                = NULL;
5850   char *induction_dir             = NULL;
5851   char *outfile_check_dir         = NULL;
5852   uint  force                     = FORCE;
5853   uint  runtime                   = RUNTIME;
5854   uint  hash_mode                 = HASH_MODE;
5855   uint  attack_mode               = ATTACK_MODE;
5856   uint  markov_disable            = MARKOV_DISABLE;
5857   uint  markov_classic            = MARKOV_CLASSIC;
5858   uint  markov_threshold          = MARKOV_THRESHOLD;
5859   char *markov_hcstat             = NULL;
5860   char *outfile                   = NULL;
5861   uint  outfile_format            = OUTFILE_FORMAT;
5862   uint  outfile_autohex           = OUTFILE_AUTOHEX;
5863   uint  outfile_check_timer       = OUTFILE_CHECK_TIMER;
5864   uint  restore                   = RESTORE;
5865   uint  restore_timer             = RESTORE_TIMER;
5866   uint  restore_disable           = RESTORE_DISABLE;
5867   uint  status                    = STATUS;
5868   uint  status_timer              = STATUS_TIMER;
5869   uint  machine_readable          = MACHINE_READABLE;
5870   uint  loopback                  = LOOPBACK;
5871   uint  weak_hash_threshold       = WEAK_HASH_THRESHOLD;
5872   char *session                   = NULL;
5873   uint  hex_charset               = HEX_CHARSET;
5874   uint  hex_salt                  = HEX_SALT;
5875   uint  hex_wordlist              = HEX_WORDLIST;
5876   uint  rp_gen                    = RP_GEN;
5877   uint  rp_gen_func_min           = RP_GEN_FUNC_MIN;
5878   uint  rp_gen_func_max           = RP_GEN_FUNC_MAX;
5879   uint  rp_gen_seed               = RP_GEN_SEED;
5880   char *rule_buf_l                = (char *) RULE_BUF_L;
5881   char *rule_buf_r                = (char *) RULE_BUF_R;
5882   uint  increment                 = INCREMENT;
5883   uint  increment_min             = INCREMENT_MIN;
5884   uint  increment_max             = INCREMENT_MAX;
5885   char *cpu_affinity              = NULL;
5886   OCL_PTR *ocl                    = NULL;
5887   char *opencl_devices            = NULL;
5888   char *opencl_platforms          = NULL;
5889   char *opencl_device_types       = NULL;
5890   uint  opencl_vector_width       = OPENCL_VECTOR_WIDTH;
5891   char *truecrypt_keyfiles        = NULL;
5892   char *veracrypt_keyfiles        = NULL;
5893   uint  veracrypt_pim             = 0;
5894   uint  workload_profile          = WORKLOAD_PROFILE;
5895   uint  kernel_accel              = KERNEL_ACCEL;
5896   uint  kernel_loops              = KERNEL_LOOPS;
5897   uint  nvidia_spin_damp          = NVIDIA_SPIN_DAMP;
5898   uint  gpu_temp_disable          = GPU_TEMP_DISABLE;
5899   #ifdef HAVE_HWMON
5900   uint  gpu_temp_abort            = GPU_TEMP_ABORT;
5901   uint  gpu_temp_retain           = GPU_TEMP_RETAIN;
5902   uint  powertune_enable          = POWERTUNE_ENABLE;
5903   #endif
5904   uint  logfile_disable           = LOGFILE_DISABLE;
5905   uint  segment_size              = SEGMENT_SIZE;
5906   uint  scrypt_tmto               = SCRYPT_TMTO;
5907   char  separator                 = SEPARATOR;
5908   uint  bitmap_min                = BITMAP_MIN;
5909   uint  bitmap_max                = BITMAP_MAX;
5910   char *custom_charset_1          = NULL;
5911   char *custom_charset_2          = NULL;
5912   char *custom_charset_3          = NULL;
5913   char *custom_charset_4          = NULL;
5914
5915   #define IDX_HELP                      'h'
5916   #define IDX_VERSION                   'V'
5917   #define IDX_VERSION_LOWER             'v'
5918   #define IDX_QUIET                     0xff02
5919   #define IDX_SHOW                      0xff03
5920   #define IDX_LEFT                      0xff04
5921   #define IDX_REMOVE                    0xff05
5922   #define IDX_REMOVE_TIMER              0xff37
5923   #define IDX_SKIP                      's'
5924   #define IDX_LIMIT                     'l'
5925   #define IDX_KEYSPACE                  0xff35
5926   #define IDX_POTFILE_DISABLE           0xff06
5927   #define IDX_POTFILE_PATH              0xffe0
5928   #define IDX_DEBUG_MODE                0xff43
5929   #define IDX_DEBUG_FILE                0xff44
5930   #define IDX_INDUCTION_DIR             0xff46
5931   #define IDX_OUTFILE_CHECK_DIR         0xff47
5932   #define IDX_USERNAME                  0xff07
5933   #define IDX_FORCE                     0xff08
5934   #define IDX_RUNTIME                   0xff09
5935   #define IDX_BENCHMARK                 'b'
5936   #define IDX_STDOUT_FLAG               0xff77
5937   #define IDX_HASH_MODE                 'm'
5938   #define IDX_ATTACK_MODE               'a'
5939   #define IDX_RP_FILE                   'r'
5940   #define IDX_RP_GEN                    'g'
5941   #define IDX_RP_GEN_FUNC_MIN           0xff10
5942   #define IDX_RP_GEN_FUNC_MAX           0xff11
5943   #define IDX_RP_GEN_SEED               0xff34
5944   #define IDX_RULE_BUF_L                'j'
5945   #define IDX_RULE_BUF_R                'k'
5946   #define IDX_INCREMENT                 'i'
5947   #define IDX_INCREMENT_MIN             0xff12
5948   #define IDX_INCREMENT_MAX             0xff13
5949   #define IDX_OUTFILE                   'o'
5950   #define IDX_OUTFILE_FORMAT            0xff14
5951   #define IDX_OUTFILE_AUTOHEX_DISABLE   0xff39
5952   #define IDX_OUTFILE_CHECK_TIMER       0xff45
5953   #define IDX_RESTORE                   0xff15
5954   #define IDX_RESTORE_DISABLE           0xff27
5955   #define IDX_STATUS                    0xff17
5956   #define IDX_STATUS_TIMER              0xff18
5957   #define IDX_MACHINE_READABLE          0xff50
5958   #define IDX_LOOPBACK                  0xff38
5959   #define IDX_WEAK_HASH_THRESHOLD       0xff42
5960   #define IDX_SESSION                   0xff19
5961   #define IDX_HEX_CHARSET               0xff20
5962   #define IDX_HEX_SALT                  0xff21
5963   #define IDX_HEX_WORDLIST              0xff40
5964   #define IDX_MARKOV_DISABLE            0xff22
5965   #define IDX_MARKOV_CLASSIC            0xff23
5966   #define IDX_MARKOV_THRESHOLD          't'
5967   #define IDX_MARKOV_HCSTAT             0xff24
5968   #define IDX_CPU_AFFINITY              0xff25
5969   #define IDX_OPENCL_DEVICES            'd'
5970   #define IDX_OPENCL_PLATFORMS          0xff72
5971   #define IDX_OPENCL_DEVICE_TYPES       'D'
5972   #define IDX_OPENCL_VECTOR_WIDTH       0xff74
5973   #define IDX_WORKLOAD_PROFILE          'w'
5974   #define IDX_KERNEL_ACCEL              'n'
5975   #define IDX_KERNEL_LOOPS              'u'
5976   #define IDX_NVIDIA_SPIN_DAMP          0xff79
5977   #define IDX_GPU_TEMP_DISABLE          0xff29
5978   #define IDX_GPU_TEMP_ABORT            0xff30
5979   #define IDX_GPU_TEMP_RETAIN           0xff31
5980   #define IDX_POWERTUNE_ENABLE          0xff41
5981   #define IDX_LOGFILE_DISABLE           0xff51
5982   #define IDX_TRUECRYPT_KEYFILES        0xff52
5983   #define IDX_VERACRYPT_KEYFILES        0xff53
5984   #define IDX_VERACRYPT_PIM             0xff54
5985   #define IDX_SCRYPT_TMTO               0xff61
5986   #define IDX_SEGMENT_SIZE              'c'
5987   #define IDX_SEPARATOR                 'p'
5988   #define IDX_BITMAP_MIN                0xff70
5989   #define IDX_BITMAP_MAX                0xff71
5990   #define IDX_CUSTOM_CHARSET_1          '1'
5991   #define IDX_CUSTOM_CHARSET_2          '2'
5992   #define IDX_CUSTOM_CHARSET_3          '3'
5993   #define IDX_CUSTOM_CHARSET_4          '4'
5994
5995   char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5996
5997   struct option long_options[] =
5998   {
5999     {"help",                      no_argument,       0, IDX_HELP},
6000     {"version",                   no_argument,       0, IDX_VERSION},
6001     {"quiet",                     no_argument,       0, IDX_QUIET},
6002     {"show",                      no_argument,       0, IDX_SHOW},
6003     {"left",                      no_argument,       0, IDX_LEFT},
6004     {"username",                  no_argument,       0, IDX_USERNAME},
6005     {"remove",                    no_argument,       0, IDX_REMOVE},
6006     {"remove-timer",              required_argument, 0, IDX_REMOVE_TIMER},
6007     {"skip",                      required_argument, 0, IDX_SKIP},
6008     {"limit",                     required_argument, 0, IDX_LIMIT},
6009     {"keyspace",                  no_argument,       0, IDX_KEYSPACE},
6010     {"potfile-disable",           no_argument,       0, IDX_POTFILE_DISABLE},
6011     {"potfile-path",              required_argument, 0, IDX_POTFILE_PATH},
6012     {"debug-mode",                required_argument, 0, IDX_DEBUG_MODE},
6013     {"debug-file",                required_argument, 0, IDX_DEBUG_FILE},
6014     {"induction-dir",             required_argument, 0, IDX_INDUCTION_DIR},
6015     {"outfile-check-dir",         required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6016     {"force",                     no_argument,       0, IDX_FORCE},
6017     {"benchmark",                 no_argument,       0, IDX_BENCHMARK},
6018     {"stdout",                    no_argument,       0, IDX_STDOUT_FLAG},
6019     {"restore",                   no_argument,       0, IDX_RESTORE},
6020     {"restore-disable",           no_argument,       0, IDX_RESTORE_DISABLE},
6021     {"status",                    no_argument,       0, IDX_STATUS},
6022     {"status-timer",              required_argument, 0, IDX_STATUS_TIMER},
6023     {"machine-readable",          no_argument,       0, IDX_MACHINE_READABLE},
6024     {"loopback",                  no_argument,       0, IDX_LOOPBACK},
6025     {"weak-hash-threshold",       required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6026     {"session",                   required_argument, 0, IDX_SESSION},
6027     {"runtime",                   required_argument, 0, IDX_RUNTIME},
6028     {"generate-rules",            required_argument, 0, IDX_RP_GEN},
6029     {"generate-rules-func-min",   required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6030     {"generate-rules-func-max",   required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6031     {"generate-rules-seed",       required_argument, 0, IDX_RP_GEN_SEED},
6032     {"rule-left",                 required_argument, 0, IDX_RULE_BUF_L},
6033     {"rule-right",                required_argument, 0, IDX_RULE_BUF_R},
6034     {"hash-type",                 required_argument, 0, IDX_HASH_MODE},
6035     {"attack-mode",               required_argument, 0, IDX_ATTACK_MODE},
6036     {"rules-file",                required_argument, 0, IDX_RP_FILE},
6037     {"outfile",                   required_argument, 0, IDX_OUTFILE},
6038     {"outfile-format",            required_argument, 0, IDX_OUTFILE_FORMAT},
6039     {"outfile-autohex-disable",   no_argument,       0, IDX_OUTFILE_AUTOHEX_DISABLE},
6040     {"outfile-check-timer",       required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6041     {"hex-charset",               no_argument,       0, IDX_HEX_CHARSET},
6042     {"hex-salt",                  no_argument,       0, IDX_HEX_SALT},
6043     {"hex-wordlist",              no_argument,       0, IDX_HEX_WORDLIST},
6044     {"markov-disable",            no_argument,       0, IDX_MARKOV_DISABLE},
6045     {"markov-classic",            no_argument,       0, IDX_MARKOV_CLASSIC},
6046     {"markov-threshold",          required_argument, 0, IDX_MARKOV_THRESHOLD},
6047     {"markov-hcstat",             required_argument, 0, IDX_MARKOV_HCSTAT},
6048     {"cpu-affinity",              required_argument, 0, IDX_CPU_AFFINITY},
6049     {"opencl-devices",            required_argument, 0, IDX_OPENCL_DEVICES},
6050     {"opencl-platforms",          required_argument, 0, IDX_OPENCL_PLATFORMS},
6051     {"opencl-device-types",       required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6052     {"opencl-vector-width",       required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6053     {"workload-profile",          required_argument, 0, IDX_WORKLOAD_PROFILE},
6054     {"kernel-accel",              required_argument, 0, IDX_KERNEL_ACCEL},
6055     {"kernel-loops",              required_argument, 0, IDX_KERNEL_LOOPS},
6056     {"nvidia-spin-damp",          required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6057     {"gpu-temp-disable",          no_argument,       0, IDX_GPU_TEMP_DISABLE},
6058     #ifdef HAVE_HWMON
6059     {"gpu-temp-abort",            required_argument, 0, IDX_GPU_TEMP_ABORT},
6060     {"gpu-temp-retain",           required_argument, 0, IDX_GPU_TEMP_RETAIN},
6061     {"powertune-enable",          no_argument,       0, IDX_POWERTUNE_ENABLE},
6062     #endif // HAVE_HWMON
6063     {"logfile-disable",           no_argument,       0, IDX_LOGFILE_DISABLE},
6064     {"truecrypt-keyfiles",        required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6065     {"veracrypt-keyfiles",        required_argument, 0, IDX_VERACRYPT_KEYFILES},
6066     {"veracrypt-pim",             required_argument, 0, IDX_VERACRYPT_PIM},
6067     {"segment-size",              required_argument, 0, IDX_SEGMENT_SIZE},
6068     {"scrypt-tmto",               required_argument, 0, IDX_SCRYPT_TMTO},
6069     {"seperator",                 required_argument, 0, IDX_SEPARATOR},
6070     {"separator",                 required_argument, 0, IDX_SEPARATOR},
6071     {"bitmap-min",                required_argument, 0, IDX_BITMAP_MIN},
6072     {"bitmap-max",                required_argument, 0, IDX_BITMAP_MAX},
6073     {"increment",                 no_argument,       0, IDX_INCREMENT},
6074     {"increment-min",             required_argument, 0, IDX_INCREMENT_MIN},
6075     {"increment-max",             required_argument, 0, IDX_INCREMENT_MAX},
6076     {"custom-charset1",           required_argument, 0, IDX_CUSTOM_CHARSET_1},
6077     {"custom-charset2",           required_argument, 0, IDX_CUSTOM_CHARSET_2},
6078     {"custom-charset3",           required_argument, 0, IDX_CUSTOM_CHARSET_3},
6079     {"custom-charset4",           required_argument, 0, IDX_CUSTOM_CHARSET_4},
6080     {0, 0, 0, 0}
6081   };
6082
6083   uint rp_files_cnt = 0;
6084
6085   char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6086
6087   int option_index = 0;
6088   int c = -1;
6089
6090   optind = 1;
6091   optopt = 0;
6092
6093   while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6094   {
6095     switch (c)
6096     {
6097       case IDX_HELP:          usage   = 1;      break;
6098       case IDX_VERSION:
6099       case IDX_VERSION_LOWER: version = 1;      break;
6100       case IDX_RESTORE:       restore = 1;      break;
6101       case IDX_SESSION:       session = optarg; break;
6102       case IDX_SHOW:          show    = 1;      break;
6103       case IDX_LEFT:          left    = 1;      break;
6104       case '?':               return (-1);
6105     }
6106   }
6107
6108   if (optopt != 0)
6109   {
6110     log_error ("ERROR: Invalid argument specified");
6111
6112     return (-1);
6113   }
6114
6115   /**
6116    * exit functions
6117    */
6118
6119   if (version)
6120   {
6121     log_info ("%s", VERSION_TAG);
6122
6123     return (0);
6124   }
6125
6126   if (usage)
6127   {
6128     usage_big_print (PROGNAME);
6129
6130     return (0);
6131   }
6132
6133   /**
6134    * session needs to be set, always!
6135    */
6136
6137   if (session == NULL) session = (char *) PROGNAME;
6138
6139   /**
6140    * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6141    */
6142
6143   char *exec_path = get_exec_path ();
6144
6145   #ifdef LINUX
6146
6147   char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6148   char *resolved_exec_path      = realpath (exec_path, NULL);
6149
6150   char *install_dir = get_install_dir (resolved_exec_path);
6151   char *profile_dir = NULL;
6152   char *session_dir = NULL;
6153   char *shared_dir  = NULL;
6154
6155   if (strcmp (install_dir, resolved_install_folder) == 0)
6156   {
6157     struct passwd *pw = getpwuid (getuid ());
6158
6159     const char *homedir = pw->pw_dir;
6160
6161     profile_dir = get_profile_dir (homedir);
6162     session_dir = get_session_dir (profile_dir);
6163     shared_dir  = strdup (SHARED_FOLDER);
6164
6165     mkdir (profile_dir, 0700);
6166     mkdir (session_dir, 0700);
6167   }
6168   else
6169   {
6170     profile_dir = install_dir;
6171     session_dir = install_dir;
6172     shared_dir  = install_dir;
6173   }
6174
6175   myfree (resolved_install_folder);
6176   myfree (resolved_exec_path);
6177
6178   #else
6179
6180   char *install_dir = get_install_dir (exec_path);
6181   char *profile_dir = install_dir;
6182   char *session_dir = install_dir;
6183   char *shared_dir  = install_dir;
6184
6185   #endif
6186
6187   data.install_dir = install_dir;
6188   data.profile_dir = profile_dir;
6189   data.session_dir = session_dir;
6190   data.shared_dir  = shared_dir;
6191
6192   myfree (exec_path);
6193
6194   /**
6195    * kernel cache, we need to make sure folder exist
6196    */
6197
6198   int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6199
6200   char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6201
6202   snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6203
6204   mkdir (kernels_folder, 0700);
6205
6206   myfree (kernels_folder);
6207
6208   /**
6209    * session
6210    */
6211
6212   size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6213
6214   data.session = session;
6215
6216   char *eff_restore_file = (char *) mymalloc (session_size);
6217   char *new_restore_file = (char *) mymalloc (session_size);
6218
6219   snprintf (eff_restore_file, session_size - 1, "%s/%s.restore",     data.session_dir, session);
6220   snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6221
6222   data.eff_restore_file = eff_restore_file;
6223   data.new_restore_file = new_restore_file;
6224
6225   if (((show == 1) || (left == 1)) && (restore == 1))
6226   {
6227     if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6228     else           log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6229
6230     return (-1);
6231   }
6232
6233   // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6234   if ((show == 1) || (left == 1))
6235   {
6236     restore_disable = 1;
6237
6238     restore = 0;
6239   }
6240
6241   data.restore_disable = restore_disable;
6242
6243   restore_data_t *rd = init_restore (argc, argv);
6244
6245   data.rd = rd;
6246
6247   /**
6248    * restore file
6249    */
6250
6251   if (restore == 1)
6252   {
6253     read_restore (eff_restore_file, rd);
6254
6255     if (rd->version_bin < RESTORE_MIN)
6256     {
6257       log_error ("ERROR: Incompatible restore-file version");
6258
6259       return (-1);
6260     }
6261
6262     myargc = rd->argc;
6263     myargv = rd->argv;
6264
6265     #ifdef _POSIX
6266     rd->pid = getpid ();
6267     #elif _WIN
6268     rd->pid = GetCurrentProcessId ();
6269     #endif
6270   }
6271
6272   uint hash_mode_chgd           = 0;
6273   uint runtime_chgd             = 0;
6274   uint kernel_loops_chgd        = 0;
6275   uint kernel_accel_chgd        = 0;
6276   uint nvidia_spin_damp_chgd    = 0;
6277   uint attack_mode_chgd         = 0;
6278   uint outfile_format_chgd      = 0;
6279   uint rp_gen_seed_chgd         = 0;
6280   uint remove_timer_chgd        = 0;
6281   uint increment_min_chgd       = 0;
6282   uint increment_max_chgd       = 0;
6283   uint workload_profile_chgd    = 0;
6284   uint opencl_vector_width_chgd = 0;
6285
6286   optind = 1;
6287   optopt = 0;
6288   option_index = 0;
6289
6290   while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6291   {
6292     switch (c)
6293     {
6294     //case IDX_HELP:                      usage                     = 1;              break;
6295     //case IDX_VERSION:                   version                   = 1;              break;
6296     //case IDX_RESTORE:                   restore                   = 1;              break;
6297       case IDX_QUIET:                     quiet                     = 1;              break;
6298     //case IDX_SHOW:                      show                      = 1;              break;
6299       case IDX_SHOW:                                                                  break;
6300     //case IDX_LEFT:                      left                      = 1;              break;
6301       case IDX_LEFT:                                                                  break;
6302       case IDX_USERNAME:                  username                  = 1;              break;
6303       case IDX_REMOVE:                    remove                    = 1;              break;
6304       case IDX_REMOVE_TIMER:              remove_timer              = atoi (optarg);
6305                                           remove_timer_chgd         = 1;              break;
6306       case IDX_POTFILE_DISABLE:           potfile_disable           = 1;              break;
6307       case IDX_POTFILE_PATH:              potfile_path              = optarg;         break;
6308       case IDX_DEBUG_MODE:                debug_mode                = atoi (optarg);  break;
6309       case IDX_DEBUG_FILE:                debug_file                = optarg;         break;
6310       case IDX_INDUCTION_DIR:             induction_dir             = optarg;         break;
6311       case IDX_OUTFILE_CHECK_DIR:         outfile_check_dir         = optarg;         break;
6312       case IDX_FORCE:                     force                     = 1;              break;
6313       case IDX_SKIP:                      skip                      = atoll (optarg); break;
6314       case IDX_LIMIT:                     limit                     = atoll (optarg); break;
6315       case IDX_KEYSPACE:                  keyspace                  = 1;              break;
6316       case IDX_BENCHMARK:                 benchmark                 = 1;              break;
6317       case IDX_STDOUT_FLAG:               stdout_flag               = 1;              break;
6318       case IDX_RESTORE:                                                               break;
6319       case IDX_RESTORE_DISABLE:           restore_disable           = 1;              break;
6320       case IDX_STATUS:                    status                    = 1;              break;
6321       case IDX_STATUS_TIMER:              status_timer              = atoi (optarg);  break;
6322       case IDX_MACHINE_READABLE:          machine_readable          = 1;              break;
6323       case IDX_LOOPBACK:                  loopback                  = 1;              break;
6324       case IDX_WEAK_HASH_THRESHOLD:       weak_hash_threshold       = atoi (optarg);  break;
6325     //case IDX_SESSION:                   session                   = optarg;         break;
6326       case IDX_SESSION:                                                               break;
6327       case IDX_HASH_MODE:                 hash_mode                 = atoi (optarg);
6328                                           hash_mode_chgd            = 1;              break;
6329       case IDX_RUNTIME:                   runtime                   = atoi (optarg);
6330                                           runtime_chgd              = 1;              break;
6331       case IDX_ATTACK_MODE:               attack_mode               = atoi (optarg);
6332                                           attack_mode_chgd          = 1;              break;
6333       case IDX_RP_FILE:                   rp_files[rp_files_cnt++]  = optarg;         break;
6334       case IDX_RP_GEN:                    rp_gen                    = atoi (optarg);  break;
6335       case IDX_RP_GEN_FUNC_MIN:           rp_gen_func_min           = atoi (optarg);  break;
6336       case IDX_RP_GEN_FUNC_MAX:           rp_gen_func_max           = atoi (optarg);  break;
6337       case IDX_RP_GEN_SEED:               rp_gen_seed               = atoi (optarg);
6338                                           rp_gen_seed_chgd          = 1;              break;
6339       case IDX_RULE_BUF_L:                rule_buf_l                = optarg;         break;
6340       case IDX_RULE_BUF_R:                rule_buf_r                = optarg;         break;
6341       case IDX_MARKOV_DISABLE:            markov_disable            = 1;              break;
6342       case IDX_MARKOV_CLASSIC:            markov_classic            = 1;              break;
6343       case IDX_MARKOV_THRESHOLD:          markov_threshold          = atoi (optarg);  break;
6344       case IDX_MARKOV_HCSTAT:             markov_hcstat             = optarg;         break;
6345       case IDX_OUTFILE:                   outfile                   = optarg;         break;
6346       case IDX_OUTFILE_FORMAT:            outfile_format            = atoi (optarg);
6347                                           outfile_format_chgd       = 1;              break;
6348       case IDX_OUTFILE_AUTOHEX_DISABLE:   outfile_autohex           = 0;              break;
6349       case IDX_OUTFILE_CHECK_TIMER:       outfile_check_timer       = atoi (optarg);  break;
6350       case IDX_HEX_CHARSET:               hex_charset               = 1;              break;
6351       case IDX_HEX_SALT:                  hex_salt                  = 1;              break;
6352       case IDX_HEX_WORDLIST:              hex_wordlist              = 1;              break;
6353       case IDX_CPU_AFFINITY:              cpu_affinity              = optarg;         break;
6354       case IDX_OPENCL_DEVICES:            opencl_devices            = optarg;         break;
6355       case IDX_OPENCL_PLATFORMS:          opencl_platforms          = optarg;         break;
6356       case IDX_OPENCL_DEVICE_TYPES:       opencl_device_types       = optarg;         break;
6357       case IDX_OPENCL_VECTOR_WIDTH:       opencl_vector_width       = atoi (optarg);
6358                                           opencl_vector_width_chgd  = 1;              break;
6359       case IDX_WORKLOAD_PROFILE:          workload_profile          = atoi (optarg);
6360                                           workload_profile_chgd     = 1;              break;
6361       case IDX_KERNEL_ACCEL:              kernel_accel              = atoi (optarg);
6362                                           kernel_accel_chgd         = 1;              break;
6363       case IDX_KERNEL_LOOPS:              kernel_loops              = atoi (optarg);
6364                                           kernel_loops_chgd         = 1;              break;
6365       case IDX_NVIDIA_SPIN_DAMP:          nvidia_spin_damp          = atoi (optarg);
6366                                           nvidia_spin_damp_chgd     = 1;              break;
6367       case IDX_GPU_TEMP_DISABLE:          gpu_temp_disable          = 1;              break;
6368       #ifdef HAVE_HWMON
6369       case IDX_GPU_TEMP_ABORT:            gpu_temp_abort            = atoi (optarg);  break;
6370       case IDX_GPU_TEMP_RETAIN:           gpu_temp_retain           = atoi (optarg);  break;
6371       case IDX_POWERTUNE_ENABLE:          powertune_enable          = 1;              break;
6372       #endif // HAVE_HWMON
6373       case IDX_LOGFILE_DISABLE:           logfile_disable           = 1;              break;
6374       case IDX_TRUECRYPT_KEYFILES:        truecrypt_keyfiles        = optarg;         break;
6375       case IDX_VERACRYPT_KEYFILES:        veracrypt_keyfiles        = optarg;         break;
6376       case IDX_VERACRYPT_PIM:             veracrypt_pim             = atoi (optarg);  break;
6377       case IDX_SEGMENT_SIZE:              segment_size              = atoi (optarg);  break;
6378       case IDX_SCRYPT_TMTO:               scrypt_tmto               = atoi (optarg);  break;
6379       case IDX_SEPARATOR:                 separator                 = optarg[0];      break;
6380       case IDX_BITMAP_MIN:                bitmap_min                = atoi (optarg);  break;
6381       case IDX_BITMAP_MAX:                bitmap_max                = atoi (optarg);  break;
6382       case IDX_INCREMENT:                 increment                 = 1;              break;
6383       case IDX_INCREMENT_MIN:             increment_min             = atoi (optarg);
6384                                           increment_min_chgd        = 1;              break;
6385       case IDX_INCREMENT_MAX:             increment_max             = atoi (optarg);
6386                                           increment_max_chgd        = 1;              break;
6387       case IDX_CUSTOM_CHARSET_1:          custom_charset_1          = optarg;         break;
6388       case IDX_CUSTOM_CHARSET_2:          custom_charset_2          = optarg;         break;
6389       case IDX_CUSTOM_CHARSET_3:          custom_charset_3          = optarg;         break;
6390       case IDX_CUSTOM_CHARSET_4:          custom_charset_4          = optarg;         break;
6391
6392       default:
6393         log_error ("ERROR: Invalid argument specified");
6394         return (-1);
6395     }
6396   }
6397
6398   if (optopt != 0)
6399   {
6400     log_error ("ERROR: Invalid argument specified");
6401
6402     return (-1);
6403   }
6404
6405   /**
6406    * Inform user things getting started,
6407    * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6408    * - we do not need to check algorithm_pos
6409    */
6410
6411   if (quiet == 0)
6412   {
6413     if (benchmark == 1)
6414     {
6415       if (machine_readable == 0)
6416       {
6417         log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6418         log_info ("");
6419       }
6420       else
6421       {
6422         log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6423       }
6424     }
6425     else if (restore == 1)
6426     {
6427       log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6428       log_info ("");
6429     }
6430     else if (stdout_flag == 1)
6431     {
6432       // do nothing
6433     }
6434     else if (keyspace == 1)
6435     {
6436       // do nothing
6437     }
6438     else
6439     {
6440       log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6441       log_info ("");
6442     }
6443   }
6444
6445   /**
6446    * sanity check
6447    */
6448
6449   if (attack_mode > 7)
6450   {
6451     log_error ("ERROR: Invalid attack-mode specified");
6452
6453     return (-1);
6454   }
6455
6456   if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6457   {
6458     log_error ("ERROR: Invalid runtime specified");
6459
6460     return (-1);
6461   }
6462
6463   if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6464   {
6465     log_error ("ERROR: Invalid hash-type specified");
6466
6467     return (-1);
6468   }
6469
6470   // renamed hash modes
6471
6472   if (hash_mode_chgd)
6473   {
6474     int n = -1;
6475
6476     switch (hash_mode)
6477     {
6478       case 123: n = 124;
6479                 break;
6480     }
6481
6482     if (n >= 0)
6483     {
6484       log_error ("Old -m specified, use -m %d instead", n);
6485
6486       return (-1);
6487     }
6488   }
6489
6490   if (username == 1)
6491   {
6492     if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6493     {
6494       log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6495
6496       return (-1);
6497     }
6498   }
6499
6500   if (outfile_format > 16)
6501   {
6502     log_error ("ERROR: Invalid outfile-format specified");
6503
6504     return (-1);
6505   }
6506
6507   if (left == 1)
6508   {
6509     if (outfile_format_chgd == 1)
6510     {
6511       if (outfile_format > 1)
6512       {
6513         log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6514
6515         return (-1);
6516       }
6517     }
6518     else
6519     {
6520       outfile_format = OUTFILE_FMT_HASH;
6521     }
6522   }
6523
6524   if (show == 1)
6525   {
6526     if (outfile_format_chgd == 1)
6527     {
6528       if ((outfile_format > 7) && (outfile_format < 16))
6529       {
6530         log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6531
6532         return (-1);
6533       }
6534     }
6535   }
6536
6537   if (increment_min < INCREMENT_MIN)
6538   {
6539     log_error ("ERROR: Invalid increment-min specified");
6540
6541     return (-1);
6542   }
6543
6544   if (increment_max > INCREMENT_MAX)
6545   {
6546     log_error ("ERROR: Invalid increment-max specified");
6547
6548     return (-1);
6549   }
6550
6551   if (increment_min > increment_max)
6552   {
6553     log_error ("ERROR: Invalid increment-min specified");
6554
6555     return (-1);
6556   }
6557
6558   if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6559   {
6560     log_error ("ERROR: Increment is not allowed in attack-mode 0");
6561
6562     return (-1);
6563   }
6564
6565   if ((increment == 0) && (increment_min_chgd == 1))
6566   {
6567     log_error ("ERROR: Increment-min is only supported combined with increment switch");
6568
6569     return (-1);
6570   }
6571
6572   if ((increment == 0) && (increment_max_chgd == 1))
6573   {
6574     log_error ("ERROR: Increment-max is only supported combined with increment switch");
6575
6576     return (-1);
6577   }
6578
6579   if (rp_files_cnt && rp_gen)
6580   {
6581     log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6582
6583     return (-1);
6584   }
6585
6586   if (rp_files_cnt || rp_gen)
6587   {
6588     if (attack_mode != ATTACK_MODE_STRAIGHT)
6589     {
6590       log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6591
6592       return (-1);
6593     }
6594   }
6595
6596   if (rp_gen_func_min > rp_gen_func_max)
6597   {
6598     log_error ("ERROR: Invalid rp-gen-func-min specified");
6599
6600     return (-1);
6601   }
6602
6603   if (kernel_accel_chgd == 1)
6604   {
6605     if (force == 0)
6606     {
6607       log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6608       log_info ("Please consider using the -w option instead");
6609       log_info ("You can use --force to override this but do not post error reports if you do so");
6610       log_info ("");
6611
6612       return (-1);
6613     }
6614
6615     if (kernel_accel < 1)
6616     {
6617       log_error ("ERROR: Invalid kernel-accel specified");
6618
6619       return (-1);
6620     }
6621
6622     if (kernel_accel > 1024)
6623     {
6624       log_error ("ERROR: Invalid kernel-accel specified");
6625
6626       return (-1);
6627     }
6628   }
6629
6630   if (kernel_loops_chgd == 1)
6631   {
6632     if (force == 0)
6633     {
6634       log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6635       log_info ("Please consider using the -w option instead");
6636       log_info ("You can use --force to override this but do not post error reports if you do so");
6637       log_info ("");
6638
6639       return (-1);
6640     }
6641
6642     if (kernel_loops < 1)
6643     {
6644       log_error ("ERROR: Invalid kernel-loops specified");
6645
6646       return (-1);
6647     }
6648
6649     if (kernel_loops > 1024)
6650     {
6651       log_error ("ERROR: Invalid kernel-loops specified");
6652
6653       return (-1);
6654     }
6655   }
6656
6657   if ((workload_profile < 1) || (workload_profile > 4))
6658   {
6659     log_error ("ERROR: workload-profile %i not available", workload_profile);
6660
6661     return (-1);
6662   }
6663
6664   if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6665   {
6666     log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6667
6668     return (-1);
6669   }
6670
6671   if (show == 1 || left == 1)
6672   {
6673     attack_mode = ATTACK_MODE_NONE;
6674
6675     if (remove == 1)
6676     {
6677       log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6678
6679       return (-1);
6680     }
6681
6682     if (potfile_disable == 1)
6683     {
6684       log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6685
6686       return (-1);
6687     }
6688   }
6689
6690   uint attack_kern = ATTACK_KERN_NONE;
6691
6692   switch (attack_mode)
6693   {
6694     case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6695     case ATTACK_MODE_COMBI:    attack_kern = ATTACK_KERN_COMBI;    break;
6696     case ATTACK_MODE_BF:       attack_kern = ATTACK_KERN_BF;       break;
6697     case ATTACK_MODE_HYBRID1:  attack_kern = ATTACK_KERN_COMBI;    break;
6698     case ATTACK_MODE_HYBRID2:  attack_kern = ATTACK_KERN_COMBI;    break;
6699   }
6700
6701   if (benchmark == 1)
6702   {
6703     if (myargv[optind] != 0)
6704     {
6705       log_error ("ERROR: Invalid argument for benchmark mode specified");
6706
6707       return (-1);
6708     }
6709
6710     if (attack_mode_chgd == 1)
6711     {
6712       if (attack_mode != ATTACK_MODE_BF)
6713       {
6714         log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6715
6716         return (-1);
6717       }
6718     }
6719   }
6720   else
6721   {
6722     if (stdout_flag == 1) // no hash here
6723     {
6724       optind--;
6725     }
6726
6727     if (keyspace == 1)
6728     {
6729       int num_additional_params = 1;
6730
6731       if (attack_kern == ATTACK_KERN_COMBI)
6732       {
6733         num_additional_params = 2;
6734       }
6735
6736       int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6737
6738       if (keyspace_wordlist_specified == 0) optind--;
6739     }
6740
6741     if (attack_kern == ATTACK_KERN_NONE)
6742     {
6743       if ((optind + 1) != myargc)
6744       {
6745         usage_mini_print (myargv[0]);
6746
6747         return (-1);
6748       }
6749     }
6750     else if (attack_kern == ATTACK_KERN_STRAIGHT)
6751     {
6752       if ((optind + 1) > myargc)
6753       {
6754         usage_mini_print (myargv[0]);
6755
6756         return (-1);
6757       }
6758     }
6759     else if (attack_kern == ATTACK_KERN_COMBI)
6760     {
6761       if ((optind + 3) != myargc)
6762       {
6763         usage_mini_print (myargv[0]);
6764
6765         return (-1);
6766       }
6767     }
6768     else if (attack_kern == ATTACK_KERN_BF)
6769     {
6770       if ((optind + 1) > myargc)
6771       {
6772         usage_mini_print (myargv[0]);
6773
6774         return (-1);
6775       }
6776     }
6777     else
6778     {
6779       usage_mini_print (myargv[0]);
6780
6781       return (-1);
6782     }
6783   }
6784
6785   if (skip != 0 && limit != 0)
6786   {
6787     limit += skip;
6788   }
6789
6790   if (keyspace == 1)
6791   {
6792     if (show == 1)
6793     {
6794       log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6795
6796       return (-1);
6797     }
6798     else if (left == 1)
6799     {
6800       log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6801
6802       return (-1);
6803     }
6804
6805     potfile_disable = 1;
6806
6807     restore_disable = 1;
6808
6809     restore = 0;
6810
6811     weak_hash_threshold = 0;
6812
6813     quiet = 1;
6814   }
6815
6816   if (stdout_flag == 1)
6817   {
6818     status_timer          = 0;
6819     restore_timer         = 0;
6820     restore_disable       = 1;
6821     restore               = 0;
6822     potfile_disable       = 1;
6823     weak_hash_threshold   = 0;
6824     gpu_temp_disable      = 1;
6825     hash_mode             = 2000;
6826     quiet                 = 1;
6827     outfile_format        = OUTFILE_FMT_PLAIN;
6828     kernel_accel          = 1024;
6829     kernel_loops          = 1024;
6830     force                 = 1;
6831     outfile_check_timer   = 0;
6832     session               = "stdout";
6833     opencl_vector_width   = 1;
6834   }
6835
6836   if (remove_timer_chgd == 1)
6837   {
6838     if (remove == 0)
6839     {
6840       log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6841
6842       return (-1);
6843     }
6844
6845     if (remove_timer < 1)
6846     {
6847       log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6848
6849       return (-1);
6850     }
6851   }
6852
6853   if (loopback == 1)
6854   {
6855     if (attack_mode == ATTACK_MODE_STRAIGHT)
6856     {
6857       if ((rp_files_cnt == 0) && (rp_gen == 0))
6858       {
6859         log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6860
6861         return (-1);
6862       }
6863     }
6864     else
6865     {
6866       log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6867
6868       return (-1);
6869     }
6870   }
6871
6872   if (debug_mode > 0)
6873   {
6874     if (attack_mode != ATTACK_MODE_STRAIGHT)
6875     {
6876       log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6877
6878       return (-1);
6879     }
6880
6881     if ((rp_files_cnt == 0) && (rp_gen == 0))
6882     {
6883       log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6884
6885       return (-1);
6886     }
6887   }
6888
6889   if (debug_mode > 4)
6890   {
6891     log_error ("ERROR: Invalid debug-mode specified");
6892
6893     return (-1);
6894   }
6895
6896   if (debug_file != NULL)
6897   {
6898     if (debug_mode < 1)
6899     {
6900       log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6901
6902       return (-1);
6903     }
6904   }
6905
6906   if (induction_dir != NULL)
6907   {
6908     if (attack_mode == ATTACK_MODE_BF)
6909     {
6910       log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6911
6912       return (-1);
6913     }
6914   }
6915
6916   if (attack_mode != ATTACK_MODE_STRAIGHT)
6917   {
6918     if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6919     {
6920       log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6921
6922       return (-1);
6923     }
6924
6925     weak_hash_threshold = 0;
6926   }
6927
6928   if (nvidia_spin_damp > 100)
6929   {
6930     log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6931
6932     return (-1);
6933   }
6934
6935
6936   /**
6937    * induction directory
6938    */
6939
6940   char *induction_directory = NULL;
6941
6942   if (attack_mode != ATTACK_MODE_BF)
6943   {
6944     if (induction_dir == NULL)
6945     {
6946       induction_directory = (char *) mymalloc (session_size);
6947
6948       snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6949
6950       // create induction folder if it does not already exist
6951
6952       if (keyspace == 0)
6953       {
6954         if (rmdir (induction_directory) == -1)
6955         {
6956           if (errno == ENOENT)
6957           {
6958             // good, we can ignore
6959           }
6960           else if (errno == ENOTEMPTY)
6961           {
6962             char *induction_directory_mv = (char *) mymalloc (session_size);
6963
6964             snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6965
6966             if (rename (induction_directory, induction_directory_mv) != 0)
6967             {
6968               log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6969
6970               return (-1);
6971             }
6972           }
6973           else
6974           {
6975             log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6976
6977             return (-1);
6978           }
6979         }
6980
6981         if (mkdir (induction_directory, 0700) == -1)
6982         {
6983           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6984
6985           return (-1);
6986         }
6987       }
6988     }
6989     else
6990     {
6991       induction_directory = induction_dir;
6992     }
6993   }
6994
6995   data.induction_directory = induction_directory;
6996
6997   /**
6998    * loopback
6999    */
7000
7001   size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7002
7003   char *loopback_file = (char *) mymalloc (loopback_size);
7004
7005   /**
7006    * tuning db
7007    */
7008
7009   char tuning_db_file[256] = { 0 };
7010
7011   snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7012
7013   tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7014
7015   /**
7016    * outfile-check directory
7017    */
7018
7019   char *outfile_check_directory = NULL;
7020
7021   if (outfile_check_dir == NULL)
7022   {
7023     outfile_check_directory = (char *) mymalloc (session_size);
7024
7025     snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7026   }
7027   else
7028   {
7029     outfile_check_directory = outfile_check_dir;
7030   }
7031
7032   data.outfile_check_directory = outfile_check_directory;
7033
7034   if (keyspace == 0)
7035   {
7036     struct stat outfile_check_stat;
7037
7038     if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7039     {
7040       uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7041
7042       if (is_dir == 0)
7043       {
7044         log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7045
7046         return (-1);
7047       }
7048     }
7049     else if (outfile_check_dir == NULL)
7050     {
7051       if (mkdir (outfile_check_directory, 0700) == -1)
7052       {
7053         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7054
7055         return (-1);
7056       }
7057     }
7058   }
7059
7060   /**
7061    * special other stuff
7062    */
7063
7064   if (hash_mode == 9710)
7065   {
7066     outfile_format      = 5;
7067     outfile_format_chgd = 1;
7068   }
7069
7070   if (hash_mode == 9810)
7071   {
7072     outfile_format      = 5;
7073     outfile_format_chgd = 1;
7074   }
7075
7076   if (hash_mode == 10410)
7077   {
7078     outfile_format      = 5;
7079     outfile_format_chgd = 1;
7080   }
7081
7082   /**
7083    * store stuff
7084    */
7085
7086   data.hash_mode               = hash_mode;
7087   data.restore                 = restore;
7088   data.restore_timer           = restore_timer;
7089   data.restore_disable         = restore_disable;
7090   data.status                  = status;
7091   data.status_timer            = status_timer;
7092   data.machine_readable        = machine_readable;
7093   data.loopback                = loopback;
7094   data.runtime                 = runtime;
7095   data.remove                  = remove;
7096   data.remove_timer            = remove_timer;
7097   data.debug_mode              = debug_mode;
7098   data.debug_file              = debug_file;
7099   data.username                = username;
7100   data.quiet                   = quiet;
7101   data.outfile                 = outfile;
7102   data.outfile_format          = outfile_format;
7103   data.outfile_autohex         = outfile_autohex;
7104   data.hex_charset             = hex_charset;
7105   data.hex_salt                = hex_salt;
7106   data.hex_wordlist            = hex_wordlist;
7107   data.separator               = separator;
7108   data.rp_files                = rp_files;
7109   data.rp_files_cnt            = rp_files_cnt;
7110   data.rp_gen                  = rp_gen;
7111   data.rp_gen_seed             = rp_gen_seed;
7112   data.force                   = force;
7113   data.benchmark               = benchmark;
7114   data.skip                    = skip;
7115   data.limit                   = limit;
7116   #ifdef HAVE_HWMON
7117   data.powertune_enable        = powertune_enable;
7118   #endif
7119   data.logfile_disable         = logfile_disable;
7120   data.truecrypt_keyfiles      = truecrypt_keyfiles;
7121   data.veracrypt_keyfiles      = veracrypt_keyfiles;
7122   data.veracrypt_pim           = veracrypt_pim;
7123   data.scrypt_tmto             = scrypt_tmto;
7124   data.workload_profile        = workload_profile;
7125
7126   /**
7127    * cpu affinity
7128    */
7129
7130   if (cpu_affinity)
7131   {
7132     set_cpu_affinity (cpu_affinity);
7133   }
7134
7135   if (rp_gen_seed_chgd == 0)
7136   {
7137     srand (proc_start);
7138   }
7139   else
7140   {
7141     srand (rp_gen_seed);
7142   }
7143
7144   /**
7145    * logfile init
7146    */
7147
7148   if (logfile_disable == 0)
7149   {
7150     size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7151
7152     char *logfile = (char *) mymalloc (logfile_size);
7153
7154     snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7155
7156     data.logfile = logfile;
7157
7158     char *topid = logfile_generate_topid ();
7159
7160     data.topid = topid;
7161   }
7162
7163   // logfile_append() checks for logfile_disable internally to make it easier from here
7164
7165   #define logfile_top_msg(msg)            logfile_append ("%s\t%s",           data.topid,             (msg));
7166   #define logfile_sub_msg(msg)            logfile_append ("%s\t%s\t%s",       data.topid, data.subid, (msg));
7167   #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu",     data.topid,             (var), (val));
7168   #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7169   #define logfile_top_var_uint(var,val)   logfile_append ("%s\t%s\t%u",       data.topid,             (var), (val));
7170   #define logfile_sub_var_uint(var,val)   logfile_append ("%s\t%s\t%s\t%u",   data.topid, data.subid, (var), (val));
7171   #define logfile_top_var_char(var,val)   logfile_append ("%s\t%s\t%c",       data.topid,             (var), (val));
7172   #define logfile_sub_var_char(var,val)   logfile_append ("%s\t%s\t%s\t%c",   data.topid, data.subid, (var), (val));
7173   #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s",       data.topid,             (var), (val));
7174   #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));
7175
7176   #define logfile_top_uint64(var)         logfile_top_var_uint64 (#var, (var));
7177   #define logfile_sub_uint64(var)         logfile_sub_var_uint64 (#var, (var));
7178   #define logfile_top_uint(var)           logfile_top_var_uint   (#var, (var));
7179   #define logfile_sub_uint(var)           logfile_sub_var_uint   (#var, (var));
7180   #define logfile_top_char(var)           logfile_top_var_char   (#var, (var));
7181   #define logfile_sub_char(var)           logfile_sub_var_char   (#var, (var));
7182   #define logfile_top_string(var)         logfile_top_var_string (#var, (var));
7183   #define logfile_sub_string(var)         logfile_sub_var_string (#var, (var));
7184
7185   logfile_top_msg ("START");
7186
7187   logfile_top_uint   (attack_mode);
7188   logfile_top_uint   (attack_kern);
7189   logfile_top_uint   (benchmark);
7190   logfile_top_uint   (stdout_flag);
7191   logfile_top_uint   (bitmap_min);
7192   logfile_top_uint   (bitmap_max);
7193   logfile_top_uint   (debug_mode);
7194   logfile_top_uint   (force);
7195   logfile_top_uint   (kernel_accel);
7196   logfile_top_uint   (kernel_loops);
7197   logfile_top_uint   (nvidia_spin_damp);
7198   logfile_top_uint   (gpu_temp_disable);
7199   #ifdef HAVE_HWMON
7200   logfile_top_uint   (gpu_temp_abort);
7201   logfile_top_uint   (gpu_temp_retain);
7202   #endif
7203   logfile_top_uint   (hash_mode);
7204   logfile_top_uint   (hex_charset);
7205   logfile_top_uint   (hex_salt);
7206   logfile_top_uint   (hex_wordlist);
7207   logfile_top_uint   (increment);
7208   logfile_top_uint   (increment_max);
7209   logfile_top_uint   (increment_min);
7210   logfile_top_uint   (keyspace);
7211   logfile_top_uint   (left);
7212   logfile_top_uint   (logfile_disable);
7213   logfile_top_uint   (loopback);
7214   logfile_top_uint   (markov_classic);
7215   logfile_top_uint   (markov_disable);
7216   logfile_top_uint   (markov_threshold);
7217   logfile_top_uint   (outfile_autohex);
7218   logfile_top_uint   (outfile_check_timer);
7219   logfile_top_uint   (outfile_format);
7220   logfile_top_uint   (potfile_disable);
7221   logfile_top_string (potfile_path);
7222   #if defined(HAVE_HWMON)
7223   logfile_top_uint   (powertune_enable);
7224   #endif
7225   logfile_top_uint   (scrypt_tmto);
7226   logfile_top_uint   (quiet);
7227   logfile_top_uint   (remove);
7228   logfile_top_uint   (remove_timer);
7229   logfile_top_uint   (restore);
7230   logfile_top_uint   (restore_disable);
7231   logfile_top_uint   (restore_timer);
7232   logfile_top_uint   (rp_gen);
7233   logfile_top_uint   (rp_gen_func_max);
7234   logfile_top_uint   (rp_gen_func_min);
7235   logfile_top_uint   (rp_gen_seed);
7236   logfile_top_uint   (runtime);
7237   logfile_top_uint   (segment_size);
7238   logfile_top_uint   (show);
7239   logfile_top_uint   (status);
7240   logfile_top_uint   (machine_readable);
7241   logfile_top_uint   (status_timer);
7242   logfile_top_uint   (usage);
7243   logfile_top_uint   (username);
7244   logfile_top_uint   (version);
7245   logfile_top_uint   (weak_hash_threshold);
7246   logfile_top_uint   (workload_profile);
7247   logfile_top_uint64 (limit);
7248   logfile_top_uint64 (skip);
7249   logfile_top_char   (separator);
7250   logfile_top_string (cpu_affinity);
7251   logfile_top_string (custom_charset_1);
7252   logfile_top_string (custom_charset_2);
7253   logfile_top_string (custom_charset_3);
7254   logfile_top_string (custom_charset_4);
7255   logfile_top_string (debug_file);
7256   logfile_top_string (opencl_devices);
7257   logfile_top_string (opencl_platforms);
7258   logfile_top_string (opencl_device_types);
7259   logfile_top_uint   (opencl_vector_width);
7260   logfile_top_string (induction_dir);
7261   logfile_top_string (markov_hcstat);
7262   logfile_top_string (outfile);
7263   logfile_top_string (outfile_check_dir);
7264   logfile_top_string (rule_buf_l);
7265   logfile_top_string (rule_buf_r);
7266   logfile_top_string (session);
7267   logfile_top_string (truecrypt_keyfiles);
7268   logfile_top_string (veracrypt_keyfiles);
7269   logfile_top_uint   (veracrypt_pim);
7270
7271   /**
7272    * Init OpenCL library loader
7273    */
7274
7275   if (keyspace == 0)
7276   {
7277     ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7278
7279     ocl_init (ocl);
7280
7281     data.ocl = ocl;
7282   }
7283
7284   /**
7285    * OpenCL platform selection
7286    */
7287
7288   u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7289
7290   /**
7291    * OpenCL device selection
7292    */
7293
7294   u32 devices_filter = setup_devices_filter (opencl_devices);
7295
7296   /**
7297    * OpenCL device type selection
7298    */
7299
7300   cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7301
7302   /**
7303    * benchmark
7304    */
7305
7306   if (benchmark == 1)
7307   {
7308     /**
7309      * disable useless stuff for benchmark
7310      */
7311
7312     status_timer          = 0;
7313     restore_timer         = 0;
7314     restore_disable       = 1;
7315     potfile_disable       = 1;
7316     weak_hash_threshold   = 0;
7317     nvidia_spin_damp      = 0;
7318     gpu_temp_disable      = 1;
7319     outfile_check_timer   = 0;
7320
7321     #ifdef HAVE_HWMON
7322     if (powertune_enable == 1)
7323     {
7324       gpu_temp_disable = 0;
7325     }
7326     #endif
7327
7328     data.status_timer         = status_timer;
7329     data.restore_timer        = restore_timer;
7330     data.restore_disable      = restore_disable;
7331     data.outfile_check_timer  = outfile_check_timer;
7332
7333     /**
7334      * force attack mode to be bruteforce
7335      */
7336
7337     attack_mode = ATTACK_MODE_BF;
7338     attack_kern = ATTACK_KERN_BF;
7339
7340     if (workload_profile_chgd == 0)
7341     {
7342       workload_profile = 3;
7343
7344       data.workload_profile = workload_profile;
7345     }
7346   }
7347
7348   /**
7349    * status, monitor and outfile remove threads
7350    */
7351
7352   uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7353
7354   data.wordlist_mode = wordlist_mode;
7355
7356   if (wordlist_mode == WL_MODE_STDIN)
7357   {
7358     status = 1;
7359
7360     data.status = status;
7361   }
7362
7363   uint i_threads_cnt = 0;
7364
7365   hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7366
7367   if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7368   {
7369     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7370     {
7371       hc_thread_create (i_threads[i_threads_cnt], thread_keypress, NULL);
7372
7373       i_threads_cnt++;
7374     }
7375   }
7376
7377   /**
7378    * config
7379    */
7380
7381   uint hash_type   = 0;
7382   uint salt_type   = 0;
7383   uint attack_exec = 0;
7384   uint opts_type   = 0;
7385   uint kern_type   = 0;
7386   uint dgst_size   = 0;
7387   uint esalt_size  = 0;
7388   uint opti_type   = 0;
7389   uint dgst_pos0   = -1;
7390   uint dgst_pos1   = -1;
7391   uint dgst_pos2   = -1;
7392   uint dgst_pos3   = -1;
7393
7394   int (*parse_func) (char *, uint, hash_t *);
7395   int (*sort_by_digest) (const void *, const void *);
7396
7397   uint algorithm_pos = 0;
7398   uint algorithm_max = 1;
7399
7400   uint *algorithms = default_benchmark_algorithms;
7401
7402   if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7403
7404   for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7405   {
7406     /*
7407      * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7408      * the following algos are skipped entirely
7409      */
7410
7411     if (algorithm_pos > 0)
7412     {
7413       local_free (rd);
7414
7415       rd = init_restore (argc, argv);
7416
7417       data.rd = rd;
7418     }
7419
7420     /**
7421      * update hash_mode in case of multihash benchmark
7422      */
7423
7424     if (benchmark == 1)
7425     {
7426       if (hash_mode_chgd == 0)
7427       {
7428         hash_mode = algorithms[algorithm_pos];
7429
7430         data.hash_mode = hash_mode;
7431       }
7432
7433       quiet = 1;
7434
7435       data.quiet = quiet;
7436     }
7437
7438     switch (hash_mode)
7439     {
7440       case     0:  hash_type   = HASH_TYPE_MD5;
7441                    salt_type   = SALT_TYPE_NONE;
7442                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7444                                | OPTS_TYPE_PT_ADD80
7445                                | OPTS_TYPE_PT_ADDBITS14;
7446                    kern_type   = KERN_TYPE_MD5;
7447                    dgst_size   = DGST_SIZE_4_4;
7448                    parse_func  = md5_parse_hash;
7449                    sort_by_digest = sort_by_digest_4_4;
7450                    opti_type   = OPTI_TYPE_ZERO_BYTE
7451                                | OPTI_TYPE_PRECOMPUTE_INIT
7452                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7453                                | OPTI_TYPE_MEET_IN_MIDDLE
7454                                | OPTI_TYPE_EARLY_SKIP
7455                                | OPTI_TYPE_NOT_ITERATED
7456                                | OPTI_TYPE_NOT_SALTED
7457                                | OPTI_TYPE_RAW_HASH;
7458                    dgst_pos0   = 0;
7459                    dgst_pos1   = 3;
7460                    dgst_pos2   = 2;
7461                    dgst_pos3   = 1;
7462                    break;
7463
7464       case    10:  hash_type   = HASH_TYPE_MD5;
7465                    salt_type   = SALT_TYPE_INTERN;
7466                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7467                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7468                                | OPTS_TYPE_ST_ADD80
7469                                | OPTS_TYPE_ST_ADDBITS14;
7470                    kern_type   = KERN_TYPE_MD5_PWSLT;
7471                    dgst_size   = DGST_SIZE_4_4;
7472                    parse_func  = md5s_parse_hash;
7473                    sort_by_digest = sort_by_digest_4_4;
7474                    opti_type   = OPTI_TYPE_ZERO_BYTE
7475                                | OPTI_TYPE_PRECOMPUTE_INIT
7476                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7477                                | OPTI_TYPE_MEET_IN_MIDDLE
7478                                | OPTI_TYPE_EARLY_SKIP
7479                                | OPTI_TYPE_NOT_ITERATED
7480                                | OPTI_TYPE_APPENDED_SALT
7481                                | OPTI_TYPE_RAW_HASH;
7482                    dgst_pos0   = 0;
7483                    dgst_pos1   = 3;
7484                    dgst_pos2   = 2;
7485                    dgst_pos3   = 1;
7486                    break;
7487
7488       case    11:  hash_type   = HASH_TYPE_MD5;
7489                    salt_type   = SALT_TYPE_INTERN;
7490                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7491                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7492                                | OPTS_TYPE_ST_ADD80
7493                                | OPTS_TYPE_ST_ADDBITS14;
7494                    kern_type   = KERN_TYPE_MD5_PWSLT;
7495                    dgst_size   = DGST_SIZE_4_4;
7496                    parse_func  = joomla_parse_hash;
7497                    sort_by_digest = sort_by_digest_4_4;
7498                    opti_type   = OPTI_TYPE_ZERO_BYTE
7499                                | OPTI_TYPE_PRECOMPUTE_INIT
7500                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7501                                | OPTI_TYPE_MEET_IN_MIDDLE
7502                                | OPTI_TYPE_EARLY_SKIP
7503                                | OPTI_TYPE_NOT_ITERATED
7504                                | OPTI_TYPE_APPENDED_SALT
7505                                | OPTI_TYPE_RAW_HASH;
7506                    dgst_pos0   = 0;
7507                    dgst_pos1   = 3;
7508                    dgst_pos2   = 2;
7509                    dgst_pos3   = 1;
7510                    break;
7511
7512       case    12:  hash_type   = HASH_TYPE_MD5;
7513                    salt_type   = SALT_TYPE_INTERN;
7514                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7515                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7516                                | OPTS_TYPE_ST_ADD80
7517                                | OPTS_TYPE_ST_ADDBITS14;
7518                    kern_type   = KERN_TYPE_MD5_PWSLT;
7519                    dgst_size   = DGST_SIZE_4_4;
7520                    parse_func  = postgresql_parse_hash;
7521                    sort_by_digest = sort_by_digest_4_4;
7522                    opti_type   = OPTI_TYPE_ZERO_BYTE
7523                                | OPTI_TYPE_PRECOMPUTE_INIT
7524                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7525                                | OPTI_TYPE_MEET_IN_MIDDLE
7526                                | OPTI_TYPE_EARLY_SKIP
7527                                | OPTI_TYPE_NOT_ITERATED
7528                                | OPTI_TYPE_APPENDED_SALT
7529                                | OPTI_TYPE_RAW_HASH;
7530                    dgst_pos0   = 0;
7531                    dgst_pos1   = 3;
7532                    dgst_pos2   = 2;
7533                    dgst_pos3   = 1;
7534                    break;
7535
7536       case    20:  hash_type   = HASH_TYPE_MD5;
7537                    salt_type   = SALT_TYPE_INTERN;
7538                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7540                                | OPTS_TYPE_PT_ADD80
7541                                | OPTS_TYPE_PT_ADDBITS14;
7542                    kern_type   = KERN_TYPE_MD5_SLTPW;
7543                    dgst_size   = DGST_SIZE_4_4;
7544                    parse_func  = md5s_parse_hash;
7545                    sort_by_digest = sort_by_digest_4_4;
7546                    opti_type   = OPTI_TYPE_ZERO_BYTE
7547                                | OPTI_TYPE_PRECOMPUTE_INIT
7548                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7549                                | OPTI_TYPE_EARLY_SKIP
7550                                | OPTI_TYPE_NOT_ITERATED
7551                                | OPTI_TYPE_PREPENDED_SALT
7552                                | OPTI_TYPE_RAW_HASH;
7553                    dgst_pos0   = 0;
7554                    dgst_pos1   = 3;
7555                    dgst_pos2   = 2;
7556                    dgst_pos3   = 1;
7557                    break;
7558
7559       case    21:  hash_type   = HASH_TYPE_MD5;
7560                    salt_type   = SALT_TYPE_INTERN;
7561                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7563                                | OPTS_TYPE_PT_ADD80
7564                                | OPTS_TYPE_PT_ADDBITS14;
7565                    kern_type   = KERN_TYPE_MD5_SLTPW;
7566                    dgst_size   = DGST_SIZE_4_4;
7567                    parse_func  = osc_parse_hash;
7568                    sort_by_digest = sort_by_digest_4_4;
7569                    opti_type   = OPTI_TYPE_ZERO_BYTE
7570                                | OPTI_TYPE_PRECOMPUTE_INIT
7571                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7572                                | OPTI_TYPE_EARLY_SKIP
7573                                | OPTI_TYPE_NOT_ITERATED
7574                                | OPTI_TYPE_PREPENDED_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    22:  hash_type   = HASH_TYPE_MD5;
7583                    salt_type   = SALT_TYPE_EMBEDDED;
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  = netscreen_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    23:  hash_type   = HASH_TYPE_MD5;
7606                    salt_type   = SALT_TYPE_EMBEDDED;
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  = skype_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    30:  hash_type   = HASH_TYPE_MD5;
7629                    salt_type   = SALT_TYPE_INTERN;
7630                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7632                                | OPTS_TYPE_PT_UNICODE
7633                                | OPTS_TYPE_ST_ADD80
7634                                | OPTS_TYPE_ST_ADDBITS14;
7635                    kern_type   = KERN_TYPE_MD5_PWUSLT;
7636                    dgst_size   = DGST_SIZE_4_4;
7637                    parse_func  = md5s_parse_hash;
7638                    sort_by_digest = sort_by_digest_4_4;
7639                    opti_type   = OPTI_TYPE_ZERO_BYTE
7640                                | OPTI_TYPE_PRECOMPUTE_INIT
7641                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7642                                | OPTI_TYPE_MEET_IN_MIDDLE
7643                                | OPTI_TYPE_EARLY_SKIP
7644                                | OPTI_TYPE_NOT_ITERATED
7645                                | OPTI_TYPE_APPENDED_SALT
7646                                | OPTI_TYPE_RAW_HASH;
7647                    dgst_pos0   = 0;
7648                    dgst_pos1   = 3;
7649                    dgst_pos2   = 2;
7650                    dgst_pos3   = 1;
7651                    break;
7652
7653       case    40:  hash_type   = HASH_TYPE_MD5;
7654                    salt_type   = SALT_TYPE_INTERN;
7655                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7656                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7657                                | OPTS_TYPE_PT_ADD80
7658                                | OPTS_TYPE_PT_ADDBITS14
7659                                | OPTS_TYPE_PT_UNICODE;
7660                    kern_type   = KERN_TYPE_MD5_SLTPWU;
7661                    dgst_size   = DGST_SIZE_4_4;
7662                    parse_func  = md5s_parse_hash;
7663                    sort_by_digest = sort_by_digest_4_4;
7664                    opti_type   = OPTI_TYPE_ZERO_BYTE
7665                                | OPTI_TYPE_PRECOMPUTE_INIT
7666                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7667                                | OPTI_TYPE_EARLY_SKIP
7668                                | OPTI_TYPE_NOT_ITERATED
7669                                | OPTI_TYPE_PREPENDED_SALT
7670                                | OPTI_TYPE_RAW_HASH;
7671                    dgst_pos0   = 0;
7672                    dgst_pos1   = 3;
7673                    dgst_pos2   = 2;
7674                    dgst_pos3   = 1;
7675                    break;
7676
7677       case    50:  hash_type   = HASH_TYPE_MD5;
7678                    salt_type   = SALT_TYPE_INTERN;
7679                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7680                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7681                                | OPTS_TYPE_ST_ADD80
7682                                | OPTS_TYPE_ST_ADDBITS14;
7683                    kern_type   = KERN_TYPE_HMACMD5_PW;
7684                    dgst_size   = DGST_SIZE_4_4;
7685                    parse_func  = hmacmd5_parse_hash;
7686                    sort_by_digest = sort_by_digest_4_4;
7687                    opti_type   = OPTI_TYPE_ZERO_BYTE
7688                                | OPTI_TYPE_NOT_ITERATED;
7689                    dgst_pos0   = 0;
7690                    dgst_pos1   = 3;
7691                    dgst_pos2   = 2;
7692                    dgst_pos3   = 1;
7693                    break;
7694
7695       case    60:  hash_type   = HASH_TYPE_MD5;
7696                    salt_type   = SALT_TYPE_INTERN;
7697                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7698                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7699                                | OPTS_TYPE_PT_ADD80
7700                                | OPTS_TYPE_PT_ADDBITS14;
7701                    kern_type   = KERN_TYPE_HMACMD5_SLT;
7702                    dgst_size   = DGST_SIZE_4_4;
7703                    parse_func  = hmacmd5_parse_hash;
7704                    sort_by_digest = sort_by_digest_4_4;
7705                    opti_type   = OPTI_TYPE_ZERO_BYTE
7706                                | OPTI_TYPE_NOT_ITERATED;
7707                    dgst_pos0   = 0;
7708                    dgst_pos1   = 3;
7709                    dgst_pos2   = 2;
7710                    dgst_pos3   = 1;
7711                    break;
7712
7713       case   100:  hash_type   = HASH_TYPE_SHA1;
7714                    salt_type   = SALT_TYPE_NONE;
7715                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7717                                | OPTS_TYPE_PT_ADD80
7718                                | OPTS_TYPE_PT_ADDBITS15;
7719                    kern_type   = KERN_TYPE_SHA1;
7720                    dgst_size   = DGST_SIZE_4_5;
7721                    parse_func  = sha1_parse_hash;
7722                    sort_by_digest = sort_by_digest_4_5;
7723                    opti_type   = OPTI_TYPE_ZERO_BYTE
7724                                | OPTI_TYPE_PRECOMPUTE_INIT
7725                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7726                                | OPTI_TYPE_EARLY_SKIP
7727                                | OPTI_TYPE_NOT_ITERATED
7728                                | OPTI_TYPE_NOT_SALTED
7729                                | OPTI_TYPE_RAW_HASH;
7730                    dgst_pos0   = 3;
7731                    dgst_pos1   = 4;
7732                    dgst_pos2   = 2;
7733                    dgst_pos3   = 1;
7734                    break;
7735
7736       case   101:  hash_type   = HASH_TYPE_SHA1;
7737                    salt_type   = SALT_TYPE_NONE;
7738                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7740                                | OPTS_TYPE_PT_ADD80
7741                                | OPTS_TYPE_PT_ADDBITS15;
7742                    kern_type   = KERN_TYPE_SHA1;
7743                    dgst_size   = DGST_SIZE_4_5;
7744                    parse_func  = sha1b64_parse_hash;
7745                    sort_by_digest = sort_by_digest_4_5;
7746                    opti_type   = OPTI_TYPE_ZERO_BYTE
7747                                | OPTI_TYPE_PRECOMPUTE_INIT
7748                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7749                                | OPTI_TYPE_EARLY_SKIP
7750                                | OPTI_TYPE_NOT_ITERATED
7751                                | OPTI_TYPE_NOT_SALTED
7752                                | OPTI_TYPE_RAW_HASH;
7753                    dgst_pos0   = 3;
7754                    dgst_pos1   = 4;
7755                    dgst_pos2   = 2;
7756                    dgst_pos3   = 1;
7757                    break;
7758
7759       case   110:  hash_type   = HASH_TYPE_SHA1;
7760                    salt_type   = SALT_TYPE_INTERN;
7761                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7763                                | OPTS_TYPE_ST_ADD80
7764                                | OPTS_TYPE_ST_ADDBITS15;
7765                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7766                    dgst_size   = DGST_SIZE_4_5;
7767                    parse_func  = sha1s_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_APPENDED_SALT
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   111:  hash_type   = HASH_TYPE_SHA1;
7783                    salt_type   = SALT_TYPE_EMBEDDED;
7784                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7786                                | OPTS_TYPE_ST_ADD80
7787                                | OPTS_TYPE_ST_ADDBITS15;
7788                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7789                    dgst_size   = DGST_SIZE_4_5;
7790                    parse_func  = sha1b64s_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_APPENDED_SALT
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   112:  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                                | OPTS_TYPE_ST_HEX;
7812                    kern_type   = KERN_TYPE_SHA1_PWSLT;
7813                    dgst_size   = DGST_SIZE_4_5;
7814                    parse_func  = oracles_parse_hash;
7815                    sort_by_digest = sort_by_digest_4_5;
7816                    opti_type   = OPTI_TYPE_ZERO_BYTE
7817                                | OPTI_TYPE_PRECOMPUTE_INIT
7818                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7819                                | OPTI_TYPE_EARLY_SKIP
7820                                | OPTI_TYPE_NOT_ITERATED
7821                                | OPTI_TYPE_APPENDED_SALT
7822                                | OPTI_TYPE_RAW_HASH;
7823                    dgst_pos0   = 3;
7824                    dgst_pos1   = 4;
7825                    dgst_pos2   = 2;
7826                    dgst_pos3   = 1;
7827                    break;
7828
7829       case   120:  hash_type   = HASH_TYPE_SHA1;
7830                    salt_type   = SALT_TYPE_INTERN;
7831                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7833                                | OPTS_TYPE_PT_ADD80
7834                                | OPTS_TYPE_PT_ADDBITS15;
7835                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7836                    dgst_size   = DGST_SIZE_4_5;
7837                    parse_func  = sha1s_parse_hash;
7838                    sort_by_digest = sort_by_digest_4_5;
7839                    opti_type   = OPTI_TYPE_ZERO_BYTE
7840                                | OPTI_TYPE_PRECOMPUTE_INIT
7841                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7842                                | OPTI_TYPE_EARLY_SKIP
7843                                | OPTI_TYPE_NOT_ITERATED
7844                                | OPTI_TYPE_PREPENDED_SALT
7845                                | OPTI_TYPE_RAW_HASH;
7846                    dgst_pos0   = 3;
7847                    dgst_pos1   = 4;
7848                    dgst_pos2   = 2;
7849                    dgst_pos3   = 1;
7850                    break;
7851
7852       case   121:  hash_type   = HASH_TYPE_SHA1;
7853                    salt_type   = SALT_TYPE_INTERN;
7854                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7856                                | OPTS_TYPE_PT_ADD80
7857                                | OPTS_TYPE_PT_ADDBITS15
7858                                | OPTS_TYPE_ST_LOWER;
7859                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7860                    dgst_size   = DGST_SIZE_4_5;
7861                    parse_func  = smf_parse_hash;
7862                    sort_by_digest = sort_by_digest_4_5;
7863                    opti_type   = OPTI_TYPE_ZERO_BYTE
7864                                | OPTI_TYPE_PRECOMPUTE_INIT
7865                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7866                                | OPTI_TYPE_EARLY_SKIP
7867                                | OPTI_TYPE_NOT_ITERATED
7868                                | OPTI_TYPE_PREPENDED_SALT
7869                                | OPTI_TYPE_RAW_HASH;
7870                    dgst_pos0   = 3;
7871                    dgst_pos1   = 4;
7872                    dgst_pos2   = 2;
7873                    dgst_pos3   = 1;
7874                    break;
7875
7876       case   122:  hash_type   = HASH_TYPE_SHA1;
7877                    salt_type   = SALT_TYPE_EMBEDDED;
7878                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7880                                | OPTS_TYPE_PT_ADD80
7881                                | OPTS_TYPE_PT_ADDBITS15
7882                                | OPTS_TYPE_ST_HEX;
7883                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7884                    dgst_size   = DGST_SIZE_4_5;
7885                    parse_func  = osx1_parse_hash;
7886                    sort_by_digest = sort_by_digest_4_5;
7887                    opti_type   = OPTI_TYPE_ZERO_BYTE
7888                                | OPTI_TYPE_PRECOMPUTE_INIT
7889                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7890                                | OPTI_TYPE_EARLY_SKIP
7891                                | OPTI_TYPE_NOT_ITERATED
7892                                | OPTI_TYPE_PREPENDED_SALT
7893                                | OPTI_TYPE_RAW_HASH;
7894                    dgst_pos0   = 3;
7895                    dgst_pos1   = 4;
7896                    dgst_pos2   = 2;
7897                    dgst_pos3   = 1;
7898                    break;
7899
7900       case   124:  hash_type   = HASH_TYPE_SHA1;
7901                    salt_type   = SALT_TYPE_EMBEDDED;
7902                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7903                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7904                                | OPTS_TYPE_PT_ADD80
7905                                | OPTS_TYPE_PT_ADDBITS15;
7906                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7907                    dgst_size   = DGST_SIZE_4_5;
7908                    parse_func  = djangosha1_parse_hash;
7909                    sort_by_digest = sort_by_digest_4_5;
7910                    opti_type   = OPTI_TYPE_ZERO_BYTE
7911                                | OPTI_TYPE_PRECOMPUTE_INIT
7912                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7913                                | OPTI_TYPE_EARLY_SKIP
7914                                | OPTI_TYPE_NOT_ITERATED
7915                                | OPTI_TYPE_PREPENDED_SALT
7916                                | OPTI_TYPE_RAW_HASH;
7917                    dgst_pos0   = 3;
7918                    dgst_pos1   = 4;
7919                    dgst_pos2   = 2;
7920                    dgst_pos3   = 1;
7921                    break;
7922
7923       case   125:  hash_type   = HASH_TYPE_SHA1;
7924                    salt_type   = SALT_TYPE_EMBEDDED;
7925                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7927                                | OPTS_TYPE_PT_ADD80
7928                                | OPTS_TYPE_PT_ADDBITS15
7929                                | OPTS_TYPE_ST_HEX;
7930                    kern_type   = KERN_TYPE_SHA1_SLTPW;
7931                    dgst_size   = DGST_SIZE_4_5;
7932                    parse_func  = arubaos_parse_hash;
7933                    sort_by_digest = sort_by_digest_4_5;
7934                    opti_type   = OPTI_TYPE_ZERO_BYTE
7935                                | OPTI_TYPE_PRECOMPUTE_INIT
7936                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7937                                | OPTI_TYPE_EARLY_SKIP
7938                                | OPTI_TYPE_NOT_ITERATED
7939                                | OPTI_TYPE_PREPENDED_SALT
7940                                | OPTI_TYPE_RAW_HASH;
7941                    dgst_pos0   = 3;
7942                    dgst_pos1   = 4;
7943                    dgst_pos2   = 2;
7944                    dgst_pos3   = 1;
7945                    break;
7946
7947       case   130:  hash_type   = HASH_TYPE_SHA1;
7948                    salt_type   = SALT_TYPE_INTERN;
7949                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7951                                | OPTS_TYPE_PT_UNICODE
7952                                | OPTS_TYPE_ST_ADD80
7953                                | OPTS_TYPE_ST_ADDBITS15;
7954                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
7955                    dgst_size   = DGST_SIZE_4_5;
7956                    parse_func  = sha1s_parse_hash;
7957                    sort_by_digest = sort_by_digest_4_5;
7958                    opti_type   = OPTI_TYPE_ZERO_BYTE
7959                                | OPTI_TYPE_PRECOMPUTE_INIT
7960                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7961                                | OPTI_TYPE_EARLY_SKIP
7962                                | OPTI_TYPE_NOT_ITERATED
7963                                | OPTI_TYPE_APPENDED_SALT
7964                                | OPTI_TYPE_RAW_HASH;
7965                    dgst_pos0   = 3;
7966                    dgst_pos1   = 4;
7967                    dgst_pos2   = 2;
7968                    dgst_pos3   = 1;
7969                    break;
7970
7971       case   131:  hash_type   = HASH_TYPE_SHA1;
7972                    salt_type   = SALT_TYPE_EMBEDDED;
7973                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
7975                                | OPTS_TYPE_PT_UNICODE
7976                                | OPTS_TYPE_PT_UPPER
7977                                | OPTS_TYPE_ST_ADD80
7978                                | OPTS_TYPE_ST_ADDBITS15
7979                                | OPTS_TYPE_ST_HEX;
7980                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
7981                    dgst_size   = DGST_SIZE_4_5;
7982                    parse_func  = mssql2000_parse_hash;
7983                    sort_by_digest = sort_by_digest_4_5;
7984                    opti_type   = OPTI_TYPE_ZERO_BYTE
7985                                | OPTI_TYPE_PRECOMPUTE_INIT
7986                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7987                                | OPTI_TYPE_EARLY_SKIP
7988                                | OPTI_TYPE_NOT_ITERATED
7989                                | OPTI_TYPE_APPENDED_SALT
7990                                | OPTI_TYPE_RAW_HASH;
7991                    dgst_pos0   = 3;
7992                    dgst_pos1   = 4;
7993                    dgst_pos2   = 2;
7994                    dgst_pos3   = 1;
7995                    break;
7996
7997       case   132:  hash_type   = HASH_TYPE_SHA1;
7998                    salt_type   = SALT_TYPE_EMBEDDED;
7999                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8001                                | OPTS_TYPE_PT_UNICODE
8002                                | OPTS_TYPE_ST_ADD80
8003                                | OPTS_TYPE_ST_ADDBITS15
8004                                | OPTS_TYPE_ST_HEX;
8005                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8006                    dgst_size   = DGST_SIZE_4_5;
8007                    parse_func  = mssql2005_parse_hash;
8008                    sort_by_digest = sort_by_digest_4_5;
8009                    opti_type   = OPTI_TYPE_ZERO_BYTE
8010                                | OPTI_TYPE_PRECOMPUTE_INIT
8011                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8012                                | OPTI_TYPE_EARLY_SKIP
8013                                | OPTI_TYPE_NOT_ITERATED
8014                                | OPTI_TYPE_APPENDED_SALT
8015                                | OPTI_TYPE_RAW_HASH;
8016                    dgst_pos0   = 3;
8017                    dgst_pos1   = 4;
8018                    dgst_pos2   = 2;
8019                    dgst_pos3   = 1;
8020                    break;
8021
8022       case   133:  hash_type   = HASH_TYPE_SHA1;
8023                    salt_type   = SALT_TYPE_EMBEDDED;
8024                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8026                                | OPTS_TYPE_PT_UNICODE
8027                                | OPTS_TYPE_ST_ADD80
8028                                | OPTS_TYPE_ST_ADDBITS15;
8029                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8030                    dgst_size   = DGST_SIZE_4_5;
8031                    parse_func  = peoplesoft_parse_hash;
8032                    sort_by_digest = sort_by_digest_4_5;
8033                    opti_type   = OPTI_TYPE_ZERO_BYTE
8034                                | OPTI_TYPE_PRECOMPUTE_INIT
8035                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8036                                | OPTI_TYPE_EARLY_SKIP
8037                                | OPTI_TYPE_NOT_ITERATED
8038                                | OPTI_TYPE_APPENDED_SALT
8039                                | OPTI_TYPE_RAW_HASH;
8040                    dgst_pos0   = 3;
8041                    dgst_pos1   = 4;
8042                    dgst_pos2   = 2;
8043                    dgst_pos3   = 1;
8044                    break;
8045
8046       case   140:  hash_type   = HASH_TYPE_SHA1;
8047                    salt_type   = SALT_TYPE_INTERN;
8048                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8050                                | OPTS_TYPE_PT_ADD80
8051                                | OPTS_TYPE_PT_ADDBITS15
8052                                | OPTS_TYPE_PT_UNICODE;
8053                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8054                    dgst_size   = DGST_SIZE_4_5;
8055                    parse_func  = sha1s_parse_hash;
8056                    sort_by_digest = sort_by_digest_4_5;
8057                    opti_type   = OPTI_TYPE_ZERO_BYTE
8058                                | OPTI_TYPE_PRECOMPUTE_INIT
8059                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8060                                | OPTI_TYPE_EARLY_SKIP
8061                                | OPTI_TYPE_NOT_ITERATED
8062                                | OPTI_TYPE_PREPENDED_SALT
8063                                | OPTI_TYPE_RAW_HASH;
8064                    dgst_pos0   = 3;
8065                    dgst_pos1   = 4;
8066                    dgst_pos2   = 2;
8067                    dgst_pos3   = 1;
8068                    break;
8069
8070       case   141:  hash_type   = HASH_TYPE_SHA1;
8071                    salt_type   = SALT_TYPE_EMBEDDED;
8072                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8074                                | OPTS_TYPE_PT_ADD80
8075                                | OPTS_TYPE_PT_ADDBITS15
8076                                | OPTS_TYPE_PT_UNICODE
8077                                | OPTS_TYPE_ST_BASE64;
8078                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8079                    dgst_size   = DGST_SIZE_4_5;
8080                    parse_func  = episerver_parse_hash;
8081                    sort_by_digest = sort_by_digest_4_5;
8082                    opti_type   = OPTI_TYPE_ZERO_BYTE
8083                                | OPTI_TYPE_PRECOMPUTE_INIT
8084                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8085                                | OPTI_TYPE_EARLY_SKIP
8086                                | OPTI_TYPE_NOT_ITERATED
8087                                | OPTI_TYPE_PREPENDED_SALT
8088                                | OPTI_TYPE_RAW_HASH;
8089                    dgst_pos0   = 3;
8090                    dgst_pos1   = 4;
8091                    dgst_pos2   = 2;
8092                    dgst_pos3   = 1;
8093                    break;
8094
8095       case   150:  hash_type   = HASH_TYPE_SHA1;
8096                    salt_type   = SALT_TYPE_INTERN;
8097                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8099                                | OPTS_TYPE_ST_ADD80
8100                                | OPTS_TYPE_ST_ADDBITS15;
8101                    kern_type   = KERN_TYPE_HMACSHA1_PW;
8102                    dgst_size   = DGST_SIZE_4_5;
8103                    parse_func  = hmacsha1_parse_hash;
8104                    sort_by_digest = sort_by_digest_4_5;
8105                    opti_type   = OPTI_TYPE_ZERO_BYTE
8106                                | OPTI_TYPE_NOT_ITERATED;
8107                    dgst_pos0   = 3;
8108                    dgst_pos1   = 4;
8109                    dgst_pos2   = 2;
8110                    dgst_pos3   = 1;
8111                    break;
8112
8113       case   160:  hash_type   = HASH_TYPE_SHA1;
8114                    salt_type   = SALT_TYPE_INTERN;
8115                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8117                                | OPTS_TYPE_PT_ADD80
8118                                | OPTS_TYPE_PT_ADDBITS15;
8119                    kern_type   = KERN_TYPE_HMACSHA1_SLT;
8120                    dgst_size   = DGST_SIZE_4_5;
8121                    parse_func  = hmacsha1_parse_hash;
8122                    sort_by_digest = sort_by_digest_4_5;
8123                    opti_type   = OPTI_TYPE_ZERO_BYTE
8124                                | OPTI_TYPE_NOT_ITERATED;
8125                    dgst_pos0   = 3;
8126                    dgst_pos1   = 4;
8127                    dgst_pos2   = 2;
8128                    dgst_pos3   = 1;
8129                    break;
8130
8131       case   200:  hash_type   = HASH_TYPE_MYSQL;
8132                    salt_type   = SALT_TYPE_NONE;
8133                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134                    opts_type   = 0;
8135                    kern_type   = KERN_TYPE_MYSQL;
8136                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8137                    parse_func  = mysql323_parse_hash;
8138                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8139                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8140                    dgst_pos0   = 0;
8141                    dgst_pos1   = 1;
8142                    dgst_pos2   = 2;
8143                    dgst_pos3   = 3;
8144                    break;
8145
8146       case   300:  hash_type   = HASH_TYPE_SHA1;
8147                    salt_type   = SALT_TYPE_NONE;
8148                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8150                                | OPTS_TYPE_PT_ADD80
8151                                | OPTS_TYPE_PT_ADDBITS15;
8152                    kern_type   = KERN_TYPE_MYSQL41;
8153                    dgst_size   = DGST_SIZE_4_5;
8154                    parse_func  = sha1_parse_hash;
8155                    sort_by_digest = sort_by_digest_4_5;
8156                    opti_type   = OPTI_TYPE_ZERO_BYTE
8157                                | OPTI_TYPE_PRECOMPUTE_INIT
8158                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8159                                | OPTI_TYPE_EARLY_SKIP
8160                                | OPTI_TYPE_NOT_ITERATED
8161                                | OPTI_TYPE_NOT_SALTED;
8162                    dgst_pos0   = 3;
8163                    dgst_pos1   = 4;
8164                    dgst_pos2   = 2;
8165                    dgst_pos3   = 1;
8166                    break;
8167
8168       case   400:  hash_type   = HASH_TYPE_MD5;
8169                    salt_type   = SALT_TYPE_EMBEDDED;
8170                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8171                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8172                    kern_type   = KERN_TYPE_PHPASS;
8173                    dgst_size   = DGST_SIZE_4_4;
8174                    parse_func  = phpass_parse_hash;
8175                    sort_by_digest = sort_by_digest_4_4;
8176                    opti_type   = OPTI_TYPE_ZERO_BYTE
8177                                | OPTI_TYPE_SLOW_HASH_SIMD;
8178                    dgst_pos0   = 0;
8179                    dgst_pos1   = 1;
8180                    dgst_pos2   = 2;
8181                    dgst_pos3   = 3;
8182                    break;
8183
8184       case   500:  hash_type   = HASH_TYPE_MD5;
8185                    salt_type   = SALT_TYPE_EMBEDDED;
8186                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8187                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8188                    kern_type   = KERN_TYPE_MD5CRYPT;
8189                    dgst_size   = DGST_SIZE_4_4;
8190                    parse_func  = md5crypt_parse_hash;
8191                    sort_by_digest = sort_by_digest_4_4;
8192                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8193                    dgst_pos0   = 0;
8194                    dgst_pos1   = 1;
8195                    dgst_pos2   = 2;
8196                    dgst_pos3   = 3;
8197                    break;
8198
8199       case   501:  hash_type   = HASH_TYPE_MD5;
8200                    salt_type   = SALT_TYPE_EMBEDDED;
8201                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8202                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8203                                | OPTS_TYPE_HASH_COPY;
8204                    kern_type   = KERN_TYPE_MD5CRYPT;
8205                    dgst_size   = DGST_SIZE_4_4;
8206                    parse_func  = juniper_parse_hash;
8207                    sort_by_digest = sort_by_digest_4_4;
8208                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8209                    dgst_pos0   = 0;
8210                    dgst_pos1   = 1;
8211                    dgst_pos2   = 2;
8212                    dgst_pos3   = 3;
8213                    break;
8214
8215       case   900:  hash_type   = HASH_TYPE_MD4;
8216                    salt_type   = SALT_TYPE_NONE;
8217                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8218                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8219                                | OPTS_TYPE_PT_ADD80
8220                                | OPTS_TYPE_PT_ADDBITS14;
8221                    kern_type   = KERN_TYPE_MD4;
8222                    dgst_size   = DGST_SIZE_4_4;
8223                    parse_func  = md4_parse_hash;
8224                    sort_by_digest = sort_by_digest_4_4;
8225                    opti_type   = OPTI_TYPE_ZERO_BYTE
8226                                | OPTI_TYPE_PRECOMPUTE_INIT
8227                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8228                                | OPTI_TYPE_MEET_IN_MIDDLE
8229                                | OPTI_TYPE_EARLY_SKIP
8230                                | OPTI_TYPE_NOT_ITERATED
8231                                | OPTI_TYPE_NOT_SALTED
8232                                | OPTI_TYPE_RAW_HASH;
8233                    dgst_pos0   = 0;
8234                    dgst_pos1   = 3;
8235                    dgst_pos2   = 2;
8236                    dgst_pos3   = 1;
8237                    break;
8238
8239       case  1000:  hash_type   = HASH_TYPE_MD4;
8240                    salt_type   = SALT_TYPE_NONE;
8241                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8243                                | OPTS_TYPE_PT_ADD80
8244                                | OPTS_TYPE_PT_ADDBITS14
8245                                | OPTS_TYPE_PT_UNICODE;
8246                    kern_type   = KERN_TYPE_MD4_PWU;
8247                    dgst_size   = DGST_SIZE_4_4;
8248                    parse_func  = md4_parse_hash;
8249                    sort_by_digest = sort_by_digest_4_4;
8250                    opti_type   = OPTI_TYPE_ZERO_BYTE
8251                                | OPTI_TYPE_PRECOMPUTE_INIT
8252                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8253                                | OPTI_TYPE_MEET_IN_MIDDLE
8254                                | OPTI_TYPE_EARLY_SKIP
8255                                | OPTI_TYPE_NOT_ITERATED
8256                                | OPTI_TYPE_NOT_SALTED
8257                                | OPTI_TYPE_RAW_HASH;
8258                    dgst_pos0   = 0;
8259                    dgst_pos1   = 3;
8260                    dgst_pos2   = 2;
8261                    dgst_pos3   = 1;
8262                    break;
8263
8264       case  1100:  hash_type   = HASH_TYPE_MD4;
8265                    salt_type   = SALT_TYPE_INTERN;
8266                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8268                                | OPTS_TYPE_PT_ADD80
8269                                | OPTS_TYPE_PT_ADDBITS14
8270                                | OPTS_TYPE_PT_UNICODE
8271                                | OPTS_TYPE_ST_ADD80
8272                                | OPTS_TYPE_ST_UNICODE
8273                                | OPTS_TYPE_ST_LOWER;
8274                    kern_type   = KERN_TYPE_MD44_PWUSLT;
8275                    dgst_size   = DGST_SIZE_4_4;
8276                    parse_func  = dcc_parse_hash;
8277                    sort_by_digest = sort_by_digest_4_4;
8278                    opti_type   = OPTI_TYPE_ZERO_BYTE
8279                                | OPTI_TYPE_PRECOMPUTE_INIT
8280                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8281                                | OPTI_TYPE_EARLY_SKIP
8282                                | OPTI_TYPE_NOT_ITERATED;
8283                    dgst_pos0   = 0;
8284                    dgst_pos1   = 3;
8285                    dgst_pos2   = 2;
8286                    dgst_pos3   = 1;
8287                    break;
8288
8289       case  1400:  hash_type   = HASH_TYPE_SHA256;
8290                    salt_type   = SALT_TYPE_NONE;
8291                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8293                                | OPTS_TYPE_PT_ADD80
8294                                | OPTS_TYPE_PT_ADDBITS15;
8295                    kern_type   = KERN_TYPE_SHA256;
8296                    dgst_size   = DGST_SIZE_4_8;
8297                    parse_func  = sha256_parse_hash;
8298                    sort_by_digest = sort_by_digest_4_8;
8299                    opti_type   = OPTI_TYPE_ZERO_BYTE
8300                                | OPTI_TYPE_PRECOMPUTE_INIT
8301                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8302                                | OPTI_TYPE_EARLY_SKIP
8303                                | OPTI_TYPE_NOT_ITERATED
8304                                | OPTI_TYPE_NOT_SALTED
8305                                | OPTI_TYPE_RAW_HASH;
8306                    dgst_pos0   = 3;
8307                    dgst_pos1   = 7;
8308                    dgst_pos2   = 2;
8309                    dgst_pos3   = 6;
8310                    break;
8311
8312       case  1410:  hash_type   = HASH_TYPE_SHA256;
8313                    salt_type   = SALT_TYPE_INTERN;
8314                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8316                                | OPTS_TYPE_ST_ADD80
8317                                | OPTS_TYPE_ST_ADDBITS15;
8318                    kern_type   = KERN_TYPE_SHA256_PWSLT;
8319                    dgst_size   = DGST_SIZE_4_8;
8320                    parse_func  = sha256s_parse_hash;
8321                    sort_by_digest = sort_by_digest_4_8;
8322                    opti_type   = OPTI_TYPE_ZERO_BYTE
8323                                | OPTI_TYPE_PRECOMPUTE_INIT
8324                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8325                                | OPTI_TYPE_EARLY_SKIP
8326                                | OPTI_TYPE_NOT_ITERATED
8327                                | OPTI_TYPE_APPENDED_SALT
8328                                | OPTI_TYPE_RAW_HASH;
8329                    dgst_pos0   = 3;
8330                    dgst_pos1   = 7;
8331                    dgst_pos2   = 2;
8332                    dgst_pos3   = 6;
8333                    break;
8334
8335       case  1420:  hash_type   = HASH_TYPE_SHA256;
8336                    salt_type   = SALT_TYPE_INTERN;
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_SLTPW;
8342                    dgst_size   = DGST_SIZE_4_8;
8343                    parse_func  = sha256s_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_PREPENDED_SALT
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  1421:  hash_type   = HASH_TYPE_SHA256;
8359                    salt_type   = SALT_TYPE_EMBEDDED;
8360                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8362                                | OPTS_TYPE_PT_ADD80
8363                                | OPTS_TYPE_PT_ADDBITS15;
8364                    kern_type   = KERN_TYPE_SHA256_SLTPW;
8365                    dgst_size   = DGST_SIZE_4_8;
8366                    parse_func  = hmailserver_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_PREPENDED_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  1430:  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_UNICODE
8386                                | OPTS_TYPE_ST_ADD80
8387                                | OPTS_TYPE_ST_ADDBITS15;
8388                    kern_type   = KERN_TYPE_SHA256_PWUSLT;
8389                    dgst_size   = DGST_SIZE_4_8;
8390                    parse_func  = sha256s_parse_hash;
8391                    sort_by_digest = sort_by_digest_4_8;
8392                    opti_type   = OPTI_TYPE_ZERO_BYTE
8393                                | OPTI_TYPE_PRECOMPUTE_INIT
8394                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8395                                | OPTI_TYPE_EARLY_SKIP
8396                                | OPTI_TYPE_NOT_ITERATED
8397                                | OPTI_TYPE_APPENDED_SALT
8398                                | OPTI_TYPE_RAW_HASH;
8399                    dgst_pos0   = 3;
8400                    dgst_pos1   = 7;
8401                    dgst_pos2   = 2;
8402                    dgst_pos3   = 6;
8403                    break;
8404
8405       case  1440:  hash_type   = HASH_TYPE_SHA256;
8406                    salt_type   = SALT_TYPE_INTERN;
8407                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8409                                | OPTS_TYPE_PT_ADD80
8410                                | OPTS_TYPE_PT_ADDBITS15
8411                                | OPTS_TYPE_PT_UNICODE;
8412                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8413                    dgst_size   = DGST_SIZE_4_8;
8414                    parse_func  = sha256s_parse_hash;
8415                    sort_by_digest = sort_by_digest_4_8;
8416                    opti_type   = OPTI_TYPE_ZERO_BYTE
8417                                | OPTI_TYPE_PRECOMPUTE_INIT
8418                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8419                                | OPTI_TYPE_EARLY_SKIP
8420                                | OPTI_TYPE_NOT_ITERATED
8421                                | OPTI_TYPE_PREPENDED_SALT
8422                                | OPTI_TYPE_RAW_HASH;
8423                    dgst_pos0   = 3;
8424                    dgst_pos1   = 7;
8425                    dgst_pos2   = 2;
8426                    dgst_pos3   = 6;
8427                    break;
8428
8429       case  1441:  hash_type   = HASH_TYPE_SHA256;
8430                    salt_type   = SALT_TYPE_EMBEDDED;
8431                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8433                                | OPTS_TYPE_PT_ADD80
8434                                | OPTS_TYPE_PT_ADDBITS15
8435                                | OPTS_TYPE_PT_UNICODE
8436                                | OPTS_TYPE_ST_BASE64;
8437                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8438                    dgst_size   = DGST_SIZE_4_8;
8439                    parse_func  = episerver4_parse_hash;
8440                    sort_by_digest = sort_by_digest_4_8;
8441                    opti_type   = OPTI_TYPE_ZERO_BYTE
8442                                | OPTI_TYPE_PRECOMPUTE_INIT
8443                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8444                                | OPTI_TYPE_EARLY_SKIP
8445                                | OPTI_TYPE_NOT_ITERATED
8446                                | OPTI_TYPE_PREPENDED_SALT
8447                                | OPTI_TYPE_RAW_HASH;
8448                    dgst_pos0   = 3;
8449                    dgst_pos1   = 7;
8450                    dgst_pos2   = 2;
8451                    dgst_pos3   = 6;
8452                    break;
8453
8454       case  1450:  hash_type   = HASH_TYPE_SHA256;
8455                    salt_type   = SALT_TYPE_INTERN;
8456                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8457                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8458                                | OPTS_TYPE_ST_ADD80;
8459                    kern_type   = KERN_TYPE_HMACSHA256_PW;
8460                    dgst_size   = DGST_SIZE_4_8;
8461                    parse_func  = hmacsha256_parse_hash;
8462                    sort_by_digest = sort_by_digest_4_8;
8463                    opti_type   = OPTI_TYPE_ZERO_BYTE
8464                                | OPTI_TYPE_NOT_ITERATED;
8465                    dgst_pos0   = 3;
8466                    dgst_pos1   = 7;
8467                    dgst_pos2   = 2;
8468                    dgst_pos3   = 6;
8469                    break;
8470
8471       case  1460:  hash_type   = HASH_TYPE_SHA256;
8472                    salt_type   = SALT_TYPE_INTERN;
8473                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8475                                | OPTS_TYPE_PT_ADD80
8476                                | OPTS_TYPE_PT_ADDBITS15;
8477                    kern_type   = KERN_TYPE_HMACSHA256_SLT;
8478                    dgst_size   = DGST_SIZE_4_8;
8479                    parse_func  = hmacsha256_parse_hash;
8480                    sort_by_digest = sort_by_digest_4_8;
8481                    opti_type   = OPTI_TYPE_ZERO_BYTE
8482                                | OPTI_TYPE_NOT_ITERATED;
8483                    dgst_pos0   = 3;
8484                    dgst_pos1   = 7;
8485                    dgst_pos2   = 2;
8486                    dgst_pos3   = 6;
8487                    break;
8488
8489       case  1500:  hash_type   = HASH_TYPE_DESCRYPT;
8490                    salt_type   = SALT_TYPE_EMBEDDED;
8491                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8492                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8493                                | OPTS_TYPE_PT_BITSLICE;
8494                    kern_type   = KERN_TYPE_DESCRYPT;
8495                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8496                    parse_func  = descrypt_parse_hash;
8497                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8498                    opti_type   = OPTI_TYPE_ZERO_BYTE
8499                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
8500                    dgst_pos0   = 0;
8501                    dgst_pos1   = 1;
8502                    dgst_pos2   = 2;
8503                    dgst_pos3   = 3;
8504                    break;
8505
8506       case  1600:  hash_type   = HASH_TYPE_MD5;
8507                    salt_type   = SALT_TYPE_EMBEDDED;
8508                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8509                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8510                    kern_type   = KERN_TYPE_APR1CRYPT;
8511                    dgst_size   = DGST_SIZE_4_4;
8512                    parse_func  = md5apr1_parse_hash;
8513                    sort_by_digest = sort_by_digest_4_4;
8514                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8515                    dgst_pos0   = 0;
8516                    dgst_pos1   = 1;
8517                    dgst_pos2   = 2;
8518                    dgst_pos3   = 3;
8519                    break;
8520
8521       case  1700:  hash_type   = HASH_TYPE_SHA512;
8522                    salt_type   = SALT_TYPE_NONE;
8523                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8524                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8525                                | OPTS_TYPE_PT_ADD80
8526                                | OPTS_TYPE_PT_ADDBITS15;
8527                    kern_type   = KERN_TYPE_SHA512;
8528                    dgst_size   = DGST_SIZE_8_8;
8529                    parse_func  = sha512_parse_hash;
8530                    sort_by_digest = sort_by_digest_8_8;
8531                    opti_type   = OPTI_TYPE_ZERO_BYTE
8532                                | OPTI_TYPE_PRECOMPUTE_INIT
8533                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8534                                | OPTI_TYPE_EARLY_SKIP
8535                                | OPTI_TYPE_NOT_ITERATED
8536                                | OPTI_TYPE_NOT_SALTED
8537                                | OPTI_TYPE_USES_BITS_64
8538                                | OPTI_TYPE_RAW_HASH;
8539                    dgst_pos0   = 14;
8540                    dgst_pos1   = 15;
8541                    dgst_pos2   = 6;
8542                    dgst_pos3   = 7;
8543                    break;
8544
8545       case  1710:  hash_type   = HASH_TYPE_SHA512;
8546                    salt_type   = SALT_TYPE_INTERN;
8547                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8549                                | OPTS_TYPE_ST_ADD80
8550                                | OPTS_TYPE_ST_ADDBITS15;
8551                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8552                    dgst_size   = DGST_SIZE_8_8;
8553                    parse_func  = sha512s_parse_hash;
8554                    sort_by_digest = sort_by_digest_8_8;
8555                    opti_type   = OPTI_TYPE_ZERO_BYTE
8556                                | OPTI_TYPE_PRECOMPUTE_INIT
8557                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8558                                | OPTI_TYPE_EARLY_SKIP
8559                                | OPTI_TYPE_NOT_ITERATED
8560                                | OPTI_TYPE_APPENDED_SALT
8561                                | OPTI_TYPE_USES_BITS_64
8562                                | OPTI_TYPE_RAW_HASH;
8563                    dgst_pos0   = 14;
8564                    dgst_pos1   = 15;
8565                    dgst_pos2   = 6;
8566                    dgst_pos3   = 7;
8567                    break;
8568
8569       case  1711:  hash_type   = HASH_TYPE_SHA512;
8570                    salt_type   = SALT_TYPE_EMBEDDED;
8571                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8572                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8573                                | OPTS_TYPE_ST_ADD80
8574                                | OPTS_TYPE_ST_ADDBITS15;
8575                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8576                    dgst_size   = DGST_SIZE_8_8;
8577                    parse_func  = sha512b64s_parse_hash;
8578                    sort_by_digest = sort_by_digest_8_8;
8579                    opti_type   = OPTI_TYPE_ZERO_BYTE
8580                                | OPTI_TYPE_PRECOMPUTE_INIT
8581                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8582                                | OPTI_TYPE_EARLY_SKIP
8583                                | OPTI_TYPE_NOT_ITERATED
8584                                | OPTI_TYPE_APPENDED_SALT
8585                                | OPTI_TYPE_USES_BITS_64
8586                                | OPTI_TYPE_RAW_HASH;
8587                    dgst_pos0   = 14;
8588                    dgst_pos1   = 15;
8589                    dgst_pos2   = 6;
8590                    dgst_pos3   = 7;
8591                    break;
8592
8593       case  1720:  hash_type   = HASH_TYPE_SHA512;
8594                    salt_type   = SALT_TYPE_INTERN;
8595                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8597                                | OPTS_TYPE_PT_ADD80
8598                                | OPTS_TYPE_PT_ADDBITS15;
8599                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8600                    dgst_size   = DGST_SIZE_8_8;
8601                    parse_func  = sha512s_parse_hash;
8602                    sort_by_digest = sort_by_digest_8_8;
8603                    opti_type   = OPTI_TYPE_ZERO_BYTE
8604                                | OPTI_TYPE_PRECOMPUTE_INIT
8605                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8606                                | OPTI_TYPE_EARLY_SKIP
8607                                | OPTI_TYPE_NOT_ITERATED
8608                                | OPTI_TYPE_PREPENDED_SALT
8609                                | OPTI_TYPE_USES_BITS_64
8610                                | OPTI_TYPE_RAW_HASH;
8611                    dgst_pos0   = 14;
8612                    dgst_pos1   = 15;
8613                    dgst_pos2   = 6;
8614                    dgst_pos3   = 7;
8615                    break;
8616
8617       case  1722:  hash_type   = HASH_TYPE_SHA512;
8618                    salt_type   = SALT_TYPE_EMBEDDED;
8619                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8621                                | OPTS_TYPE_PT_ADD80
8622                                | OPTS_TYPE_PT_ADDBITS15
8623                                | OPTS_TYPE_ST_HEX;
8624                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8625                    dgst_size   = DGST_SIZE_8_8;
8626                    parse_func  = osx512_parse_hash;
8627                    sort_by_digest = sort_by_digest_8_8;
8628                    opti_type   = OPTI_TYPE_ZERO_BYTE
8629                                | OPTI_TYPE_PRECOMPUTE_INIT
8630                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8631                                | OPTI_TYPE_EARLY_SKIP
8632                                | OPTI_TYPE_NOT_ITERATED
8633                                | OPTI_TYPE_PREPENDED_SALT
8634                                | OPTI_TYPE_USES_BITS_64
8635                                | OPTI_TYPE_RAW_HASH;
8636                    dgst_pos0   = 14;
8637                    dgst_pos1   = 15;
8638                    dgst_pos2   = 6;
8639                    dgst_pos3   = 7;
8640                    break;
8641
8642       case  1730:  hash_type   = HASH_TYPE_SHA512;
8643                    salt_type   = SALT_TYPE_INTERN;
8644                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8645                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8646                                | OPTS_TYPE_PT_UNICODE
8647                                | OPTS_TYPE_ST_ADD80
8648                                | OPTS_TYPE_ST_ADDBITS15;
8649                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
8650                    dgst_size   = DGST_SIZE_8_8;
8651                    parse_func  = sha512s_parse_hash;
8652                    sort_by_digest = sort_by_digest_8_8;
8653                    opti_type   = OPTI_TYPE_ZERO_BYTE
8654                                | OPTI_TYPE_PRECOMPUTE_INIT
8655                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8656                                | OPTI_TYPE_EARLY_SKIP
8657                                | OPTI_TYPE_NOT_ITERATED
8658                                | OPTI_TYPE_APPENDED_SALT
8659                                | OPTI_TYPE_USES_BITS_64
8660                                | OPTI_TYPE_RAW_HASH;
8661                    dgst_pos0   = 14;
8662                    dgst_pos1   = 15;
8663                    dgst_pos2   = 6;
8664                    dgst_pos3   = 7;
8665                    break;
8666
8667       case  1731:  hash_type   = HASH_TYPE_SHA512;
8668                    salt_type   = SALT_TYPE_EMBEDDED;
8669                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8670                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8671                                | OPTS_TYPE_PT_UNICODE
8672                                | OPTS_TYPE_ST_ADD80
8673                                | OPTS_TYPE_ST_ADDBITS15
8674                                | OPTS_TYPE_ST_HEX;
8675                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
8676                    dgst_size   = DGST_SIZE_8_8;
8677                    parse_func  = mssql2012_parse_hash;
8678                    sort_by_digest = sort_by_digest_8_8;
8679                    opti_type   = OPTI_TYPE_ZERO_BYTE
8680                                | OPTI_TYPE_PRECOMPUTE_INIT
8681                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8682                                | OPTI_TYPE_EARLY_SKIP
8683                                | OPTI_TYPE_NOT_ITERATED
8684                                | OPTI_TYPE_APPENDED_SALT
8685                                | OPTI_TYPE_USES_BITS_64
8686                                | OPTI_TYPE_RAW_HASH;
8687                    dgst_pos0   = 14;
8688                    dgst_pos1   = 15;
8689                    dgst_pos2   = 6;
8690                    dgst_pos3   = 7;
8691                    break;
8692
8693       case  1740:  hash_type   = HASH_TYPE_SHA512;
8694                    salt_type   = SALT_TYPE_INTERN;
8695                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8696                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8697                                | OPTS_TYPE_PT_ADD80
8698                                | OPTS_TYPE_PT_ADDBITS15
8699                                | OPTS_TYPE_PT_UNICODE;
8700                    kern_type   = KERN_TYPE_SHA512_SLTPWU;
8701                    dgst_size   = DGST_SIZE_8_8;
8702                    parse_func  = sha512s_parse_hash;
8703                    sort_by_digest = sort_by_digest_8_8;
8704                    opti_type   = OPTI_TYPE_ZERO_BYTE
8705                                | OPTI_TYPE_PRECOMPUTE_INIT
8706                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8707                                | OPTI_TYPE_EARLY_SKIP
8708                                | OPTI_TYPE_NOT_ITERATED
8709                                | OPTI_TYPE_PREPENDED_SALT
8710                                | OPTI_TYPE_USES_BITS_64
8711                                | OPTI_TYPE_RAW_HASH;
8712                    dgst_pos0   = 14;
8713                    dgst_pos1   = 15;
8714                    dgst_pos2   = 6;
8715                    dgst_pos3   = 7;
8716                    break;
8717
8718       case  1750:  hash_type   = HASH_TYPE_SHA512;
8719                    salt_type   = SALT_TYPE_INTERN;
8720                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8722                                | OPTS_TYPE_ST_ADD80;
8723                    kern_type   = KERN_TYPE_HMACSHA512_PW;
8724                    dgst_size   = DGST_SIZE_8_8;
8725                    parse_func  = hmacsha512_parse_hash;
8726                    sort_by_digest = sort_by_digest_8_8;
8727                    opti_type   = OPTI_TYPE_ZERO_BYTE
8728                                | OPTI_TYPE_USES_BITS_64
8729                                | OPTI_TYPE_NOT_ITERATED;
8730                    dgst_pos0   = 14;
8731                    dgst_pos1   = 15;
8732                    dgst_pos2   = 6;
8733                    dgst_pos3   = 7;
8734                    break;
8735
8736       case  1760:  hash_type   = HASH_TYPE_SHA512;
8737                    salt_type   = SALT_TYPE_INTERN;
8738                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8739                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8740                                | OPTS_TYPE_PT_ADD80
8741                                | OPTS_TYPE_PT_ADDBITS15;
8742                    kern_type   = KERN_TYPE_HMACSHA512_SLT;
8743                    dgst_size   = DGST_SIZE_8_8;
8744                    parse_func  = hmacsha512_parse_hash;
8745                    sort_by_digest = sort_by_digest_8_8;
8746                    opti_type   = OPTI_TYPE_ZERO_BYTE
8747                                | OPTI_TYPE_USES_BITS_64
8748                                | OPTI_TYPE_NOT_ITERATED;
8749                    dgst_pos0   = 14;
8750                    dgst_pos1   = 15;
8751                    dgst_pos2   = 6;
8752                    dgst_pos3   = 7;
8753                    break;
8754
8755       case  1800:  hash_type   = HASH_TYPE_SHA512;
8756                    salt_type   = SALT_TYPE_EMBEDDED;
8757                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8758                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8759                    kern_type   = KERN_TYPE_SHA512CRYPT;
8760                    dgst_size   = DGST_SIZE_8_8;
8761                    parse_func  = sha512crypt_parse_hash;
8762                    sort_by_digest = sort_by_digest_8_8;
8763                    opti_type   = OPTI_TYPE_ZERO_BYTE
8764                                | OPTI_TYPE_USES_BITS_64;
8765                    dgst_pos0   = 0;
8766                    dgst_pos1   = 1;
8767                    dgst_pos2   = 2;
8768                    dgst_pos3   = 3;
8769                    break;
8770
8771       case  2000:  hash_type   = HASH_TYPE_STDOUT;
8772                    salt_type   = SALT_TYPE_NONE;
8773                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8774                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8775                    kern_type   = KERN_TYPE_STDOUT;
8776                    dgst_size   = DGST_SIZE_4_4;
8777                    parse_func  = NULL;
8778                    sort_by_digest = NULL;
8779                    opti_type   = 0;
8780                    dgst_pos0   = 0;
8781                    dgst_pos1   = 0;
8782                    dgst_pos2   = 0;
8783                    dgst_pos3   = 0;
8784                    break;
8785
8786       case  2100:  hash_type   = HASH_TYPE_DCC2;
8787                    salt_type   = SALT_TYPE_EMBEDDED;
8788                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
8790                                | OPTS_TYPE_ST_LOWER
8791                                | OPTS_TYPE_ST_UNICODE;
8792                    kern_type   = KERN_TYPE_DCC2;
8793                    dgst_size   = DGST_SIZE_4_4;
8794                    parse_func  = dcc2_parse_hash;
8795                    sort_by_digest = sort_by_digest_4_4;
8796                    opti_type   = OPTI_TYPE_ZERO_BYTE
8797                                | OPTI_TYPE_SLOW_HASH_SIMD;
8798                    dgst_pos0   = 0;
8799                    dgst_pos1   = 1;
8800                    dgst_pos2   = 2;
8801                    dgst_pos3   = 3;
8802                    break;
8803
8804       case  2400:  hash_type   = HASH_TYPE_MD5;
8805                    salt_type   = SALT_TYPE_NONE;
8806                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8807                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8808                    kern_type   = KERN_TYPE_MD5PIX;
8809                    dgst_size   = DGST_SIZE_4_4;
8810                    parse_func  = md5pix_parse_hash;
8811                    sort_by_digest = sort_by_digest_4_4;
8812                    opti_type   = OPTI_TYPE_ZERO_BYTE
8813                                | OPTI_TYPE_PRECOMPUTE_INIT
8814                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8815                                | OPTI_TYPE_EARLY_SKIP
8816                                | OPTI_TYPE_NOT_ITERATED
8817                                | OPTI_TYPE_NOT_SALTED;
8818                    dgst_pos0   = 0;
8819                    dgst_pos1   = 3;
8820                    dgst_pos2   = 2;
8821                    dgst_pos3   = 1;
8822                    break;
8823
8824       case  2410:  hash_type   = HASH_TYPE_MD5;
8825                    salt_type   = SALT_TYPE_INTERN;
8826                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8827                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8828                    kern_type   = KERN_TYPE_MD5ASA;
8829                    dgst_size   = DGST_SIZE_4_4;
8830                    parse_func  = md5asa_parse_hash;
8831                    sort_by_digest = sort_by_digest_4_4;
8832                    opti_type   = OPTI_TYPE_ZERO_BYTE
8833                                | OPTI_TYPE_PRECOMPUTE_INIT
8834                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8835                                | OPTI_TYPE_EARLY_SKIP
8836                                | OPTI_TYPE_NOT_ITERATED;
8837                    dgst_pos0   = 0;
8838                    dgst_pos1   = 3;
8839                    dgst_pos2   = 2;
8840                    dgst_pos3   = 1;
8841                    break;
8842
8843       case  2500:  hash_type   = HASH_TYPE_WPA;
8844                    salt_type   = SALT_TYPE_EMBEDDED;
8845                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847                    kern_type   = KERN_TYPE_WPA;
8848                    dgst_size   = DGST_SIZE_4_4;
8849                    parse_func  = wpa_parse_hash;
8850                    sort_by_digest = sort_by_digest_4_4;
8851                    opti_type   = OPTI_TYPE_ZERO_BYTE
8852                                | OPTI_TYPE_SLOW_HASH_SIMD;
8853                    dgst_pos0   = 0;
8854                    dgst_pos1   = 1;
8855                    dgst_pos2   = 2;
8856                    dgst_pos3   = 3;
8857                    break;
8858
8859       case  2600:  hash_type   = HASH_TYPE_MD5;
8860                    salt_type   = SALT_TYPE_VIRTUAL;
8861                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8862                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8863                                | OPTS_TYPE_PT_ADD80
8864                                | OPTS_TYPE_PT_ADDBITS14
8865                                | OPTS_TYPE_ST_ADD80;
8866                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8867                    dgst_size   = DGST_SIZE_4_4;
8868                    parse_func  = md5md5_parse_hash;
8869                    sort_by_digest = sort_by_digest_4_4;
8870                    opti_type   = OPTI_TYPE_ZERO_BYTE
8871                                | OPTI_TYPE_PRECOMPUTE_INIT
8872                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8873                                | OPTI_TYPE_EARLY_SKIP;
8874                    dgst_pos0   = 0;
8875                    dgst_pos1   = 3;
8876                    dgst_pos2   = 2;
8877                    dgst_pos3   = 1;
8878                    break;
8879
8880       case  2611:  hash_type   = HASH_TYPE_MD5;
8881                    salt_type   = SALT_TYPE_INTERN;
8882                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8883                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8884                                | OPTS_TYPE_PT_ADD80
8885                                | OPTS_TYPE_PT_ADDBITS14
8886                                | OPTS_TYPE_ST_ADD80;
8887                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8888                    dgst_size   = DGST_SIZE_4_4;
8889                    parse_func  = vb3_parse_hash;
8890                    sort_by_digest = sort_by_digest_4_4;
8891                    opti_type   = OPTI_TYPE_ZERO_BYTE
8892                                | OPTI_TYPE_PRECOMPUTE_INIT
8893                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8894                                | OPTI_TYPE_EARLY_SKIP;
8895                    dgst_pos0   = 0;
8896                    dgst_pos1   = 3;
8897                    dgst_pos2   = 2;
8898                    dgst_pos3   = 1;
8899                    break;
8900
8901       case  2612:  hash_type   = HASH_TYPE_MD5;
8902                    salt_type   = SALT_TYPE_EMBEDDED;
8903                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8904                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8905                                | OPTS_TYPE_PT_ADD80
8906                                | OPTS_TYPE_PT_ADDBITS14
8907                                | OPTS_TYPE_ST_ADD80
8908                                | OPTS_TYPE_ST_HEX;
8909                    kern_type   = KERN_TYPE_MD55_PWSLT1;
8910                    dgst_size   = DGST_SIZE_4_4;
8911                    parse_func  = phps_parse_hash;
8912                    sort_by_digest = sort_by_digest_4_4;
8913                    opti_type   = OPTI_TYPE_ZERO_BYTE
8914                                | OPTI_TYPE_PRECOMPUTE_INIT
8915                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8916                                | OPTI_TYPE_EARLY_SKIP;
8917                    dgst_pos0   = 0;
8918                    dgst_pos1   = 3;
8919                    dgst_pos2   = 2;
8920                    dgst_pos3   = 1;
8921                    break;
8922
8923       case  2711:  hash_type   = HASH_TYPE_MD5;
8924                    salt_type   = SALT_TYPE_INTERN;
8925                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8927                                | OPTS_TYPE_PT_ADD80
8928                                | OPTS_TYPE_PT_ADDBITS14
8929                                | OPTS_TYPE_ST_ADD80;
8930                    kern_type   = KERN_TYPE_MD55_PWSLT2;
8931                    dgst_size   = DGST_SIZE_4_4;
8932                    parse_func  = vb30_parse_hash;
8933                    sort_by_digest = sort_by_digest_4_4;
8934                    opti_type   = OPTI_TYPE_ZERO_BYTE
8935                                | OPTI_TYPE_PRECOMPUTE_INIT
8936                                | OPTI_TYPE_EARLY_SKIP;
8937                    dgst_pos0   = 0;
8938                    dgst_pos1   = 3;
8939                    dgst_pos2   = 2;
8940                    dgst_pos3   = 1;
8941                    break;
8942
8943       case  2811:  hash_type   = HASH_TYPE_MD5;
8944                    salt_type   = SALT_TYPE_INTERN;
8945                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8947                                | OPTS_TYPE_PT_ADD80
8948                                | OPTS_TYPE_PT_ADDBITS14;
8949                    kern_type   = KERN_TYPE_MD55_SLTPW;
8950                    dgst_size   = DGST_SIZE_4_4;
8951                    parse_func  = ipb2_parse_hash;
8952                    sort_by_digest = sort_by_digest_4_4;
8953                    opti_type   = OPTI_TYPE_ZERO_BYTE
8954                                | OPTI_TYPE_PRECOMPUTE_INIT
8955                                | OPTI_TYPE_EARLY_SKIP;
8956                    dgst_pos0   = 0;
8957                    dgst_pos1   = 3;
8958                    dgst_pos2   = 2;
8959                    dgst_pos3   = 1;
8960                    break;
8961
8962       case  3000:  hash_type   = HASH_TYPE_LM;
8963                    salt_type   = SALT_TYPE_NONE;
8964                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8965                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8966                                | OPTS_TYPE_PT_UPPER
8967                                | OPTS_TYPE_PT_BITSLICE;
8968                    kern_type   = KERN_TYPE_LM;
8969                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8970                    parse_func  = lm_parse_hash;
8971                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8972                    opti_type   = OPTI_TYPE_ZERO_BYTE
8973                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
8974                    dgst_pos0   = 0;
8975                    dgst_pos1   = 1;
8976                    dgst_pos2   = 2;
8977                    dgst_pos3   = 3;
8978                    break;
8979
8980       case  3100:  hash_type   = HASH_TYPE_ORACLEH;
8981                    salt_type   = SALT_TYPE_INTERN;
8982                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8983                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8984                                | OPTS_TYPE_PT_UPPER
8985                                | OPTS_TYPE_ST_UPPER;
8986                    kern_type   = KERN_TYPE_ORACLEH;
8987                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8988                    parse_func  = oracleh_parse_hash;
8989                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8990                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8991                    dgst_pos0   = 0;
8992                    dgst_pos1   = 1;
8993                    dgst_pos2   = 2;
8994                    dgst_pos3   = 3;
8995                    break;
8996
8997       case  3200:  hash_type   = HASH_TYPE_BCRYPT;
8998                    salt_type   = SALT_TYPE_EMBEDDED;
8999                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9001                                | OPTS_TYPE_ST_GENERATE_LE;
9002                    kern_type   = KERN_TYPE_BCRYPT;
9003                    dgst_size   = DGST_SIZE_4_6;
9004                    parse_func  = bcrypt_parse_hash;
9005                    sort_by_digest = sort_by_digest_4_6;
9006                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9007                    dgst_pos0   = 0;
9008                    dgst_pos1   = 1;
9009                    dgst_pos2   = 2;
9010                    dgst_pos3   = 3;
9011                    break;
9012
9013       case  3710:  hash_type   = HASH_TYPE_MD5;
9014                    salt_type   = SALT_TYPE_INTERN;
9015                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9016                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9017                                | OPTS_TYPE_PT_ADD80
9018                                | OPTS_TYPE_PT_ADDBITS14;
9019                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9020                    dgst_size   = DGST_SIZE_4_4;
9021                    parse_func  = md5s_parse_hash;
9022                    sort_by_digest = sort_by_digest_4_4;
9023                    opti_type   = OPTI_TYPE_ZERO_BYTE
9024                                | OPTI_TYPE_PRECOMPUTE_INIT
9025                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9026                                | OPTI_TYPE_EARLY_SKIP;
9027                    dgst_pos0   = 0;
9028                    dgst_pos1   = 3;
9029                    dgst_pos2   = 2;
9030                    dgst_pos3   = 1;
9031                    break;
9032
9033       case  3711:  hash_type   = HASH_TYPE_MD5;
9034                    salt_type   = SALT_TYPE_EMBEDDED;
9035                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9036                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9037                                | OPTS_TYPE_PT_ADD80
9038                                | OPTS_TYPE_PT_ADDBITS14;
9039                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9040                    dgst_size   = DGST_SIZE_4_4;
9041                    parse_func  = mediawiki_b_parse_hash;
9042                    sort_by_digest = sort_by_digest_4_4;
9043                    opti_type   = OPTI_TYPE_ZERO_BYTE
9044                                | OPTI_TYPE_PRECOMPUTE_INIT
9045                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9046                                | OPTI_TYPE_EARLY_SKIP;
9047                    dgst_pos0   = 0;
9048                    dgst_pos1   = 3;
9049                    dgst_pos2   = 2;
9050                    dgst_pos3   = 1;
9051                    break;
9052
9053       case  3800:  hash_type   = HASH_TYPE_MD5;
9054                    salt_type   = SALT_TYPE_INTERN;
9055                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9057                                | OPTS_TYPE_ST_ADDBITS14;
9058                    kern_type   = KERN_TYPE_MD5_SLT_PW_SLT;
9059                    dgst_size   = DGST_SIZE_4_4;
9060                    parse_func  = md5s_parse_hash;
9061                    sort_by_digest = sort_by_digest_4_4;
9062                    opti_type   = OPTI_TYPE_ZERO_BYTE
9063                                | OPTI_TYPE_PRECOMPUTE_INIT
9064                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9065                                | OPTI_TYPE_EARLY_SKIP
9066                                | OPTI_TYPE_NOT_ITERATED
9067                                | OPTI_TYPE_RAW_HASH;
9068                    dgst_pos0   = 0;
9069                    dgst_pos1   = 3;
9070                    dgst_pos2   = 2;
9071                    dgst_pos3   = 1;
9072                    break;
9073
9074       case  4300:  hash_type   = HASH_TYPE_MD5;
9075                    salt_type   = SALT_TYPE_VIRTUAL;
9076                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9077                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9078                                | OPTS_TYPE_PT_ADD80
9079                                | OPTS_TYPE_PT_ADDBITS14
9080                                | OPTS_TYPE_ST_ADD80;
9081                    kern_type   = KERN_TYPE_MD5U5_PWSLT1;
9082                    dgst_size   = DGST_SIZE_4_4;
9083                    parse_func  = md5md5_parse_hash;
9084                    sort_by_digest = sort_by_digest_4_4;
9085                    opti_type   = OPTI_TYPE_ZERO_BYTE
9086                                | OPTI_TYPE_PRECOMPUTE_INIT
9087                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9088                                | OPTI_TYPE_EARLY_SKIP;
9089                    dgst_pos0   = 0;
9090                    dgst_pos1   = 3;
9091                    dgst_pos2   = 2;
9092                    dgst_pos3   = 1;
9093                    break;
9094
9095
9096       case  4400:  hash_type   = HASH_TYPE_MD5;
9097                    salt_type   = SALT_TYPE_NONE;
9098                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9099                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9100                                | OPTS_TYPE_PT_ADD80
9101                                | OPTS_TYPE_PT_ADDBITS15;
9102                    kern_type   = KERN_TYPE_MD5_SHA1;
9103                    dgst_size   = DGST_SIZE_4_4;
9104                    parse_func  = md5_parse_hash;
9105                    sort_by_digest = sort_by_digest_4_4;
9106                    opti_type   = OPTI_TYPE_ZERO_BYTE
9107                                | OPTI_TYPE_PRECOMPUTE_INIT
9108                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9109                                | OPTI_TYPE_EARLY_SKIP
9110                                | OPTI_TYPE_NOT_ITERATED
9111                                | OPTI_TYPE_NOT_SALTED
9112                                | OPTI_TYPE_RAW_HASH;
9113                    dgst_pos0   = 0;
9114                    dgst_pos1   = 3;
9115                    dgst_pos2   = 2;
9116                    dgst_pos3   = 1;
9117                    break;
9118
9119       case  4500:  hash_type   = HASH_TYPE_SHA1;
9120                    salt_type   = SALT_TYPE_NONE;
9121                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9123                                | OPTS_TYPE_PT_ADD80
9124                                | OPTS_TYPE_PT_ADDBITS15;
9125                    kern_type   = KERN_TYPE_SHA11;
9126                    dgst_size   = DGST_SIZE_4_5;
9127                    parse_func  = sha1_parse_hash;
9128                    sort_by_digest = sort_by_digest_4_5;
9129                    opti_type   = OPTI_TYPE_ZERO_BYTE
9130                                | OPTI_TYPE_PRECOMPUTE_INIT
9131                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9132                                | OPTI_TYPE_EARLY_SKIP
9133                                | OPTI_TYPE_NOT_SALTED;
9134                    dgst_pos0   = 3;
9135                    dgst_pos1   = 4;
9136                    dgst_pos2   = 2;
9137                    dgst_pos3   = 1;
9138                    break;
9139
9140       case  4700:  hash_type   = HASH_TYPE_SHA1;
9141                    salt_type   = SALT_TYPE_NONE;
9142                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9144                                | OPTS_TYPE_PT_ADD80
9145                                | OPTS_TYPE_PT_ADDBITS14;
9146                    kern_type   = KERN_TYPE_SHA1_MD5;
9147                    dgst_size   = DGST_SIZE_4_5;
9148                    parse_func  = sha1_parse_hash;
9149                    sort_by_digest = sort_by_digest_4_5;
9150                    opti_type   = OPTI_TYPE_ZERO_BYTE
9151                                | OPTI_TYPE_PRECOMPUTE_INIT
9152                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9153                                | OPTI_TYPE_EARLY_SKIP
9154                                | OPTI_TYPE_NOT_ITERATED
9155                                | OPTI_TYPE_NOT_SALTED
9156                                | OPTI_TYPE_RAW_HASH;
9157                    dgst_pos0   = 3;
9158                    dgst_pos1   = 4;
9159                    dgst_pos2   = 2;
9160                    dgst_pos3   = 1;
9161                    break;
9162
9163       case  4800:  hash_type   = HASH_TYPE_MD5;
9164                    salt_type   = SALT_TYPE_EMBEDDED;
9165                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9166                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9167                                | OPTS_TYPE_PT_ADDBITS14;
9168                    kern_type   = KERN_TYPE_MD5_CHAP;
9169                    dgst_size   = DGST_SIZE_4_4;
9170                    parse_func  = chap_parse_hash;
9171                    sort_by_digest = sort_by_digest_4_4;
9172                    opti_type   = OPTI_TYPE_ZERO_BYTE
9173                                | OPTI_TYPE_PRECOMPUTE_INIT
9174                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9175                                | OPTI_TYPE_MEET_IN_MIDDLE
9176                                | OPTI_TYPE_EARLY_SKIP
9177                                | OPTI_TYPE_NOT_ITERATED
9178                                | OPTI_TYPE_RAW_HASH;
9179                    dgst_pos0   = 0;
9180                    dgst_pos1   = 3;
9181                    dgst_pos2   = 2;
9182                    dgst_pos3   = 1;
9183                    break;
9184
9185       case  4900:  hash_type   = HASH_TYPE_SHA1;
9186                    salt_type   = SALT_TYPE_INTERN;
9187                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9189                    kern_type   = KERN_TYPE_SHA1_SLT_PW_SLT;
9190                    dgst_size   = DGST_SIZE_4_5;
9191                    parse_func  = sha1s_parse_hash;
9192                    sort_by_digest = sort_by_digest_4_5;
9193                    opti_type   = OPTI_TYPE_ZERO_BYTE
9194                                | OPTI_TYPE_PRECOMPUTE_INIT
9195                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9196                                | OPTI_TYPE_EARLY_SKIP;
9197                    dgst_pos0   = 3;
9198                    dgst_pos1   = 4;
9199                    dgst_pos2   = 2;
9200                    dgst_pos3   = 1;
9201                    break;
9202
9203       case  5000:  hash_type   = HASH_TYPE_KECCAK;
9204                    salt_type   = SALT_TYPE_EMBEDDED;
9205                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9206                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9207                                | OPTS_TYPE_PT_ADD01;
9208                    kern_type   = KERN_TYPE_KECCAK;
9209                    dgst_size   = DGST_SIZE_8_25;
9210                    parse_func  = keccak_parse_hash;
9211                    sort_by_digest = sort_by_digest_8_25;
9212                    opti_type   = OPTI_TYPE_ZERO_BYTE
9213                                | OPTI_TYPE_USES_BITS_64
9214                                | OPTI_TYPE_RAW_HASH;
9215                    dgst_pos0   = 2;
9216                    dgst_pos1   = 3;
9217                    dgst_pos2   = 4;
9218                    dgst_pos3   = 5;
9219                    break;
9220
9221       case  5100:  hash_type   = HASH_TYPE_MD5H;
9222                    salt_type   = SALT_TYPE_NONE;
9223                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9224                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9225                                | OPTS_TYPE_PT_ADD80
9226                                | OPTS_TYPE_PT_ADDBITS14;
9227                    kern_type   = KERN_TYPE_MD5H;
9228                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9229                    parse_func  = md5half_parse_hash;
9230                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9231                    opti_type   = OPTI_TYPE_ZERO_BYTE
9232                                | OPTI_TYPE_RAW_HASH;
9233                    dgst_pos0   = 0;
9234                    dgst_pos1   = 1;
9235                    dgst_pos2   = 2;
9236                    dgst_pos3   = 3;
9237                    break;
9238
9239       case  5200:  hash_type   = HASH_TYPE_SHA256;
9240                    salt_type   = SALT_TYPE_EMBEDDED;
9241                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9242                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9243                    kern_type   = KERN_TYPE_PSAFE3;
9244                    dgst_size   = DGST_SIZE_4_8;
9245                    parse_func  = psafe3_parse_hash;
9246                    sort_by_digest = sort_by_digest_4_8;
9247                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9248                    dgst_pos0   = 0;
9249                    dgst_pos1   = 1;
9250                    dgst_pos2   = 2;
9251                    dgst_pos3   = 3;
9252                    break;
9253
9254       case  5300:  hash_type   = HASH_TYPE_MD5;
9255                    salt_type   = SALT_TYPE_EMBEDDED;
9256                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9258                                | OPTS_TYPE_ST_ADD80;
9259                    kern_type   = KERN_TYPE_IKEPSK_MD5;
9260                    dgst_size   = DGST_SIZE_4_4;
9261                    parse_func  = ikepsk_md5_parse_hash;
9262                    sort_by_digest = sort_by_digest_4_4;
9263                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9264                    dgst_pos0   = 0;
9265                    dgst_pos1   = 3;
9266                    dgst_pos2   = 2;
9267                    dgst_pos3   = 1;
9268                    break;
9269
9270       case  5400:  hash_type   = HASH_TYPE_SHA1;
9271                    salt_type   = SALT_TYPE_EMBEDDED;
9272                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9274                                | OPTS_TYPE_ST_ADD80;
9275                    kern_type   = KERN_TYPE_IKEPSK_SHA1;
9276                    dgst_size   = DGST_SIZE_4_5;
9277                    parse_func  = ikepsk_sha1_parse_hash;
9278                    sort_by_digest = sort_by_digest_4_5;
9279                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9280                    dgst_pos0   = 3;
9281                    dgst_pos1   = 4;
9282                    dgst_pos2   = 2;
9283                    dgst_pos3   = 1;
9284                    break;
9285
9286       case  5500:  hash_type   = HASH_TYPE_NETNTLM;
9287                    salt_type   = SALT_TYPE_EMBEDDED;
9288                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9290                                | OPTS_TYPE_PT_ADD80
9291                                | OPTS_TYPE_PT_ADDBITS14
9292                                | OPTS_TYPE_PT_UNICODE
9293                                | OPTS_TYPE_ST_HEX;
9294                    kern_type   = KERN_TYPE_NETNTLMv1;
9295                    dgst_size   = DGST_SIZE_4_4;
9296                    parse_func  = netntlmv1_parse_hash;
9297                    sort_by_digest = sort_by_digest_4_4;
9298                    opti_type   = OPTI_TYPE_ZERO_BYTE
9299                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9300                    dgst_pos0   = 0;
9301                    dgst_pos1   = 1;
9302                    dgst_pos2   = 2;
9303                    dgst_pos3   = 3;
9304                    break;
9305
9306       case  5600:  hash_type   = HASH_TYPE_MD5;
9307                    salt_type   = SALT_TYPE_EMBEDDED;
9308                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9310                                | OPTS_TYPE_PT_ADD80
9311                                | OPTS_TYPE_PT_ADDBITS14
9312                                | OPTS_TYPE_PT_UNICODE;
9313                    kern_type   = KERN_TYPE_NETNTLMv2;
9314                    dgst_size   = DGST_SIZE_4_4;
9315                    parse_func  = netntlmv2_parse_hash;
9316                    sort_by_digest = sort_by_digest_4_4;
9317                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9318                    dgst_pos0   = 0;
9319                    dgst_pos1   = 3;
9320                    dgst_pos2   = 2;
9321                    dgst_pos3   = 1;
9322                    break;
9323
9324       case  5700:  hash_type   = HASH_TYPE_SHA256;
9325                    salt_type   = SALT_TYPE_NONE;
9326                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9327                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9328                                | OPTS_TYPE_PT_ADD80
9329                                | OPTS_TYPE_PT_ADDBITS15;
9330                    kern_type   = KERN_TYPE_SHA256;
9331                    dgst_size   = DGST_SIZE_4_8;
9332                    parse_func  = cisco4_parse_hash;
9333                    sort_by_digest = sort_by_digest_4_8;
9334                    opti_type   = OPTI_TYPE_ZERO_BYTE
9335                                | OPTI_TYPE_PRECOMPUTE_INIT
9336                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9337                                | OPTI_TYPE_EARLY_SKIP
9338                                | OPTI_TYPE_NOT_ITERATED
9339                                | OPTI_TYPE_NOT_SALTED
9340                                | OPTI_TYPE_RAW_HASH;
9341                    dgst_pos0   = 3;
9342                    dgst_pos1   = 7;
9343                    dgst_pos2   = 2;
9344                    dgst_pos3   = 6;
9345                    break;
9346
9347       case  5800:  hash_type   = HASH_TYPE_SHA1;
9348                    salt_type   = SALT_TYPE_INTERN;
9349                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9350                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
9351                                | OPTS_TYPE_ST_ADD80;
9352                    kern_type   = KERN_TYPE_ANDROIDPIN;
9353                    dgst_size   = DGST_SIZE_4_5;
9354                    parse_func  = androidpin_parse_hash;
9355                    sort_by_digest = sort_by_digest_4_5;
9356                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9357                    dgst_pos0   = 0;
9358                    dgst_pos1   = 1;
9359                    dgst_pos2   = 2;
9360                    dgst_pos3   = 3;
9361                    break;
9362
9363       case  6000:  hash_type   = HASH_TYPE_RIPEMD160;
9364                    salt_type   = SALT_TYPE_NONE;
9365                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9366                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9367                                | OPTS_TYPE_PT_ADD80;
9368                    kern_type   = KERN_TYPE_RIPEMD160;
9369                    dgst_size   = DGST_SIZE_4_5;
9370                    parse_func  = ripemd160_parse_hash;
9371                    sort_by_digest = sort_by_digest_4_5;
9372                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9373                    dgst_pos0   = 0;
9374                    dgst_pos1   = 1;
9375                    dgst_pos2   = 2;
9376                    dgst_pos3   = 3;
9377                    break;
9378
9379       case  6100:  hash_type   = HASH_TYPE_WHIRLPOOL;
9380                    salt_type   = SALT_TYPE_NONE;
9381                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9382                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9383                                | OPTS_TYPE_PT_ADD80;
9384                    kern_type   = KERN_TYPE_WHIRLPOOL;
9385                    dgst_size   = DGST_SIZE_4_16;
9386                    parse_func  = whirlpool_parse_hash;
9387                    sort_by_digest = sort_by_digest_4_16;
9388                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9389                    dgst_pos0   = 0;
9390                    dgst_pos1   = 1;
9391                    dgst_pos2   = 2;
9392                    dgst_pos3   = 3;
9393                    break;
9394
9395       case  6211:  hash_type   = HASH_TYPE_RIPEMD160;
9396                    salt_type   = SALT_TYPE_EMBEDDED;
9397                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9398                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9399                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9400                    dgst_size   = DGST_SIZE_4_5;
9401                    parse_func  = truecrypt_parse_hash_2k;
9402                    sort_by_digest = sort_by_digest_4_5;
9403                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9404                    dgst_pos0   = 0;
9405                    dgst_pos1   = 1;
9406                    dgst_pos2   = 2;
9407                    dgst_pos3   = 3;
9408                    break;
9409
9410       case  6212:  hash_type   = HASH_TYPE_RIPEMD160;
9411                    salt_type   = SALT_TYPE_EMBEDDED;
9412                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9413                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9414                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9415                    dgst_size   = DGST_SIZE_4_5;
9416                    parse_func  = truecrypt_parse_hash_2k;
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  6213:  hash_type   = HASH_TYPE_RIPEMD160;
9426                    salt_type   = SALT_TYPE_EMBEDDED;
9427                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9429                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9430                    dgst_size   = DGST_SIZE_4_5;
9431                    parse_func  = truecrypt_parse_hash_2k;
9432                    sort_by_digest = sort_by_digest_4_5;
9433                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9434                    dgst_pos0   = 0;
9435                    dgst_pos1   = 1;
9436                    dgst_pos2   = 2;
9437                    dgst_pos3   = 3;
9438                    break;
9439
9440       case  6221:  hash_type   = HASH_TYPE_SHA512;
9441                    salt_type   = SALT_TYPE_EMBEDDED;
9442                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9444                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
9445                    dgst_size   = DGST_SIZE_8_8;
9446                    parse_func  = truecrypt_parse_hash_1k;
9447                    sort_by_digest = sort_by_digest_8_8;
9448                    opti_type   = OPTI_TYPE_ZERO_BYTE
9449                                | OPTI_TYPE_USES_BITS_64;
9450                    dgst_pos0   = 0;
9451                    dgst_pos1   = 1;
9452                    dgst_pos2   = 2;
9453                    dgst_pos3   = 3;
9454                    break;
9455
9456       case  6222:  hash_type   = HASH_TYPE_SHA512;
9457                    salt_type   = SALT_TYPE_EMBEDDED;
9458                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9460                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
9461                    dgst_size   = DGST_SIZE_8_8;
9462                    parse_func  = truecrypt_parse_hash_1k;
9463                    sort_by_digest = sort_by_digest_8_8;
9464                    opti_type   = OPTI_TYPE_ZERO_BYTE
9465                                | OPTI_TYPE_USES_BITS_64;
9466                    dgst_pos0   = 0;
9467                    dgst_pos1   = 1;
9468                    dgst_pos2   = 2;
9469                    dgst_pos3   = 3;
9470                    break;
9471
9472       case  6223:  hash_type   = HASH_TYPE_SHA512;
9473                    salt_type   = SALT_TYPE_EMBEDDED;
9474                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9475                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9476                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
9477                    dgst_size   = DGST_SIZE_8_8;
9478                    parse_func  = truecrypt_parse_hash_1k;
9479                    sort_by_digest = sort_by_digest_8_8;
9480                    opti_type   = OPTI_TYPE_ZERO_BYTE
9481                                | OPTI_TYPE_USES_BITS_64;
9482                    dgst_pos0   = 0;
9483                    dgst_pos1   = 1;
9484                    dgst_pos2   = 2;
9485                    dgst_pos3   = 3;
9486                    break;
9487
9488       case  6231:  hash_type   = HASH_TYPE_WHIRLPOOL;
9489                    salt_type   = SALT_TYPE_EMBEDDED;
9490                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9491                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9492                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
9493                    dgst_size   = DGST_SIZE_4_8;
9494                    parse_func  = truecrypt_parse_hash_1k;
9495                    sort_by_digest = sort_by_digest_4_8;
9496                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9497                    dgst_pos0   = 0;
9498                    dgst_pos1   = 1;
9499                    dgst_pos2   = 2;
9500                    dgst_pos3   = 3;
9501                    break;
9502
9503       case  6232:  hash_type   = HASH_TYPE_WHIRLPOOL;
9504                    salt_type   = SALT_TYPE_EMBEDDED;
9505                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9507                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9508                    dgst_size   = DGST_SIZE_4_8;
9509                    parse_func  = truecrypt_parse_hash_1k;
9510                    sort_by_digest = sort_by_digest_4_8;
9511                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9512                    dgst_pos0   = 0;
9513                    dgst_pos1   = 1;
9514                    dgst_pos2   = 2;
9515                    dgst_pos3   = 3;
9516                    break;
9517
9518       case  6233:  hash_type   = HASH_TYPE_WHIRLPOOL;
9519                    salt_type   = SALT_TYPE_EMBEDDED;
9520                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9522                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9523                    dgst_size   = DGST_SIZE_4_8;
9524                    parse_func  = truecrypt_parse_hash_1k;
9525                    sort_by_digest = sort_by_digest_4_8;
9526                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9527                    dgst_pos0   = 0;
9528                    dgst_pos1   = 1;
9529                    dgst_pos2   = 2;
9530                    dgst_pos3   = 3;
9531                    break;
9532
9533       case  6241:  hash_type   = HASH_TYPE_RIPEMD160;
9534                    salt_type   = SALT_TYPE_EMBEDDED;
9535                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9537                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9538                    dgst_size   = DGST_SIZE_4_5;
9539                    parse_func  = truecrypt_parse_hash_1k;
9540                    sort_by_digest = sort_by_digest_4_5;
9541                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9542                    dgst_pos0   = 0;
9543                    dgst_pos1   = 1;
9544                    dgst_pos2   = 2;
9545                    dgst_pos3   = 3;
9546                    break;
9547
9548       case  6242:  hash_type   = HASH_TYPE_RIPEMD160;
9549                    salt_type   = SALT_TYPE_EMBEDDED;
9550                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9552                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9553                    dgst_size   = DGST_SIZE_4_5;
9554                    parse_func  = truecrypt_parse_hash_1k;
9555                    sort_by_digest = sort_by_digest_4_5;
9556                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9557                    dgst_pos0   = 0;
9558                    dgst_pos1   = 1;
9559                    dgst_pos2   = 2;
9560                    dgst_pos3   = 3;
9561                    break;
9562
9563       case  6243:  hash_type   = HASH_TYPE_RIPEMD160;
9564                    salt_type   = SALT_TYPE_EMBEDDED;
9565                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9566                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9567                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9568                    dgst_size   = DGST_SIZE_4_5;
9569                    parse_func  = truecrypt_parse_hash_1k;
9570                    sort_by_digest = sort_by_digest_4_5;
9571                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9572                    dgst_pos0   = 0;
9573                    dgst_pos1   = 1;
9574                    dgst_pos2   = 2;
9575                    dgst_pos3   = 3;
9576                    break;
9577
9578       case  6300:  hash_type   = HASH_TYPE_MD5;
9579                    salt_type   = SALT_TYPE_EMBEDDED;
9580                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9581                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9582                    kern_type   = KERN_TYPE_MD5AIX;
9583                    dgst_size   = DGST_SIZE_4_4;
9584                    parse_func  = md5aix_parse_hash;
9585                    sort_by_digest = sort_by_digest_4_4;
9586                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9587                    dgst_pos0   = 0;
9588                    dgst_pos1   = 1;
9589                    dgst_pos2   = 2;
9590                    dgst_pos3   = 3;
9591                    break;
9592
9593       case  6400:  hash_type   = HASH_TYPE_SHA256;
9594                    salt_type   = SALT_TYPE_EMBEDDED;
9595                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9596                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9597                    kern_type   = KERN_TYPE_SHA256AIX;
9598                    dgst_size   = DGST_SIZE_4_8;
9599                    parse_func  = sha256aix_parse_hash;
9600                    sort_by_digest = sort_by_digest_4_8;
9601                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9602                    dgst_pos0   = 0;
9603                    dgst_pos1   = 1;
9604                    dgst_pos2   = 2;
9605                    dgst_pos3   = 3;
9606                    break;
9607
9608       case  6500:  hash_type   = HASH_TYPE_SHA512;
9609                    salt_type   = SALT_TYPE_EMBEDDED;
9610                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9611                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9612                    kern_type   = KERN_TYPE_SHA512AIX;
9613                    dgst_size   = DGST_SIZE_8_8;
9614                    parse_func  = sha512aix_parse_hash;
9615                    sort_by_digest = sort_by_digest_8_8;
9616                    opti_type   = OPTI_TYPE_ZERO_BYTE
9617                                | OPTI_TYPE_USES_BITS_64;
9618                    dgst_pos0   = 0;
9619                    dgst_pos1   = 1;
9620                    dgst_pos2   = 2;
9621                    dgst_pos3   = 3;
9622                    break;
9623
9624       case  6600:  hash_type   = HASH_TYPE_AES;
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_AGILEKEY;
9629                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
9630                    parse_func  = agilekey_parse_hash;
9631                    sort_by_digest = sort_by_digest_4_5;
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  6700:  hash_type   = HASH_TYPE_SHA1;
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_SHA1AIX;
9644                    dgst_size   = DGST_SIZE_4_5;
9645                    parse_func  = sha1aix_parse_hash;
9646                    sort_by_digest = sort_by_digest_4_5;
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  6800:  hash_type   = HASH_TYPE_AES;
9655                    salt_type   = SALT_TYPE_EMBEDDED;
9656                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9657                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9658                    kern_type   = KERN_TYPE_LASTPASS;
9659                    dgst_size   = DGST_SIZE_4_8; // because kernel uses _SHA256_
9660                    parse_func  = lastpass_parse_hash;
9661                    sort_by_digest = sort_by_digest_4_8;
9662                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9663                    dgst_pos0   = 0;
9664                    dgst_pos1   = 1;
9665                    dgst_pos2   = 2;
9666                    dgst_pos3   = 3;
9667                    break;
9668
9669       case  6900:  hash_type   = HASH_TYPE_GOST;
9670                    salt_type   = SALT_TYPE_NONE;
9671                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9672                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9673                    kern_type   = KERN_TYPE_GOST;
9674                    dgst_size   = DGST_SIZE_4_8;
9675                    parse_func  = gost_parse_hash;
9676                    sort_by_digest = sort_by_digest_4_8;
9677                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9678                    dgst_pos0   = 0;
9679                    dgst_pos1   = 1;
9680                    dgst_pos2   = 2;
9681                    dgst_pos3   = 3;
9682                    break;
9683
9684       case  7100:  hash_type   = HASH_TYPE_SHA512;
9685                    salt_type   = SALT_TYPE_EMBEDDED;
9686                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9688                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
9689                    dgst_size   = DGST_SIZE_8_16;
9690                    parse_func  = sha512osx_parse_hash;
9691                    sort_by_digest = sort_by_digest_8_16;
9692                    opti_type   = OPTI_TYPE_ZERO_BYTE
9693                                | OPTI_TYPE_USES_BITS_64
9694                                | OPTI_TYPE_SLOW_HASH_SIMD;
9695                    dgst_pos0   = 0;
9696                    dgst_pos1   = 1;
9697                    dgst_pos2   = 2;
9698                    dgst_pos3   = 3;
9699                    break;
9700
9701       case  7200:  hash_type   = HASH_TYPE_SHA512;
9702                    salt_type   = SALT_TYPE_EMBEDDED;
9703                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9704                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9705                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
9706                    dgst_size   = DGST_SIZE_8_16;
9707                    parse_func  = sha512grub_parse_hash;
9708                    sort_by_digest = sort_by_digest_8_16;
9709                    opti_type   = OPTI_TYPE_ZERO_BYTE
9710                                | OPTI_TYPE_USES_BITS_64
9711                                | OPTI_TYPE_SLOW_HASH_SIMD;
9712                    dgst_pos0   = 0;
9713                    dgst_pos1   = 1;
9714                    dgst_pos2   = 2;
9715                    dgst_pos3   = 3;
9716                    break;
9717
9718       case  7300:  hash_type   = HASH_TYPE_SHA1;
9719                    salt_type   = SALT_TYPE_EMBEDDED;
9720                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9721                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9722                                | OPTS_TYPE_ST_ADD80
9723                                | OPTS_TYPE_ST_ADDBITS15;
9724                    kern_type   = KERN_TYPE_RAKP;
9725                    dgst_size   = DGST_SIZE_4_5;
9726                    parse_func  = rakp_parse_hash;
9727                    sort_by_digest = sort_by_digest_4_5;
9728                    opti_type   = OPTI_TYPE_ZERO_BYTE
9729                                | OPTI_TYPE_NOT_ITERATED;
9730                    dgst_pos0   = 3;
9731                    dgst_pos1   = 4;
9732                    dgst_pos2   = 2;
9733                    dgst_pos3   = 1;
9734                    break;
9735
9736       case  7400:  hash_type   = HASH_TYPE_SHA256;
9737                    salt_type   = SALT_TYPE_EMBEDDED;
9738                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9739                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9740                    kern_type   = KERN_TYPE_SHA256CRYPT;
9741                    dgst_size   = DGST_SIZE_4_8;
9742                    parse_func  = sha256crypt_parse_hash;
9743                    sort_by_digest = sort_by_digest_4_8;
9744                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9745                    dgst_pos0   = 0;
9746                    dgst_pos1   = 1;
9747                    dgst_pos2   = 2;
9748                    dgst_pos3   = 3;
9749                    break;
9750
9751       case  7500:  hash_type   = HASH_TYPE_KRB5PA;
9752                    salt_type   = SALT_TYPE_EMBEDDED;
9753                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9755                    kern_type   = KERN_TYPE_KRB5PA;
9756                    dgst_size   = DGST_SIZE_4_4;
9757                    parse_func  = krb5pa_parse_hash;
9758                    sort_by_digest = sort_by_digest_4_4;
9759                    opti_type   = OPTI_TYPE_ZERO_BYTE
9760                                | OPTI_TYPE_NOT_ITERATED;
9761                    dgst_pos0   = 0;
9762                    dgst_pos1   = 1;
9763                    dgst_pos2   = 2;
9764                    dgst_pos3   = 3;
9765                    break;
9766
9767       case  7600:  hash_type   = HASH_TYPE_SHA1;
9768                    salt_type   = SALT_TYPE_INTERN;
9769                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9771                                | OPTS_TYPE_PT_ADD80
9772                                | OPTS_TYPE_PT_ADDBITS15;
9773                    kern_type   = KERN_TYPE_SHA1_SLT_SHA1_PW;
9774                    dgst_size   = DGST_SIZE_4_5;
9775                    parse_func  = redmine_parse_hash;
9776                    sort_by_digest = sort_by_digest_4_5;
9777                    opti_type   = OPTI_TYPE_ZERO_BYTE
9778                                | OPTI_TYPE_PRECOMPUTE_INIT
9779                                | OPTI_TYPE_EARLY_SKIP
9780                                | OPTI_TYPE_NOT_ITERATED
9781                                | OPTI_TYPE_PREPENDED_SALT;
9782                    dgst_pos0   = 3;
9783                    dgst_pos1   = 4;
9784                    dgst_pos2   = 2;
9785                    dgst_pos3   = 1;
9786                    break;
9787
9788       case  7700:  hash_type   = HASH_TYPE_SAPB;
9789                    salt_type   = SALT_TYPE_EMBEDDED;
9790                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9792                                | OPTS_TYPE_PT_UPPER
9793                                | OPTS_TYPE_ST_UPPER;
9794                    kern_type   = KERN_TYPE_SAPB;
9795                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9796                    parse_func  = sapb_parse_hash;
9797                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9798                    opti_type   = OPTI_TYPE_ZERO_BYTE
9799                                | OPTI_TYPE_PRECOMPUTE_INIT
9800                                | OPTI_TYPE_NOT_ITERATED;
9801                    dgst_pos0   = 0;
9802                    dgst_pos1   = 1;
9803                    dgst_pos2   = 2;
9804                    dgst_pos3   = 3;
9805                    break;
9806
9807       case  7800:  hash_type   = HASH_TYPE_SAPG;
9808                    salt_type   = SALT_TYPE_EMBEDDED;
9809                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9810                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9811                                | OPTS_TYPE_ST_ADD80
9812                                | OPTS_TYPE_ST_UPPER;
9813                    kern_type   = KERN_TYPE_SAPG;
9814                    dgst_size   = DGST_SIZE_4_5;
9815                    parse_func  = sapg_parse_hash;
9816                    sort_by_digest = sort_by_digest_4_5;
9817                    opti_type   = OPTI_TYPE_ZERO_BYTE
9818                                | OPTI_TYPE_PRECOMPUTE_INIT
9819                                | OPTI_TYPE_NOT_ITERATED;
9820                    dgst_pos0   = 3;
9821                    dgst_pos1   = 4;
9822                    dgst_pos2   = 2;
9823                    dgst_pos3   = 1;
9824                    break;
9825
9826       case  7900:  hash_type   = HASH_TYPE_SHA512;
9827                    salt_type   = SALT_TYPE_EMBEDDED;
9828                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9829                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9830                    kern_type   = KERN_TYPE_DRUPAL7;
9831                    dgst_size   = DGST_SIZE_8_8;
9832                    parse_func  = drupal7_parse_hash;
9833                    sort_by_digest = sort_by_digest_8_8;
9834                    opti_type   = OPTI_TYPE_ZERO_BYTE
9835                                | OPTI_TYPE_USES_BITS_64;
9836                    dgst_pos0   = 0;
9837                    dgst_pos1   = 1;
9838                    dgst_pos2   = 2;
9839                    dgst_pos3   = 3;
9840                    break;
9841
9842       case  8000:  hash_type   = HASH_TYPE_SHA256;
9843                    salt_type   = SALT_TYPE_EMBEDDED;
9844                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9846                                | OPTS_TYPE_PT_UNICODE
9847                                | OPTS_TYPE_ST_ADD80
9848                                | OPTS_TYPE_ST_HEX;
9849                    kern_type   = KERN_TYPE_SYBASEASE;
9850                    dgst_size   = DGST_SIZE_4_8;
9851                    parse_func  = sybasease_parse_hash;
9852                    sort_by_digest = sort_by_digest_4_8;
9853                    opti_type   = OPTI_TYPE_ZERO_BYTE
9854                                | OPTI_TYPE_PRECOMPUTE_INIT
9855                                | OPTI_TYPE_EARLY_SKIP
9856                                | OPTI_TYPE_NOT_ITERATED
9857                                | OPTI_TYPE_RAW_HASH;
9858                    dgst_pos0   = 3;
9859                    dgst_pos1   = 7;
9860                    dgst_pos2   = 2;
9861                    dgst_pos3   = 6;
9862                    break;
9863
9864       case  8100:  hash_type   = HASH_TYPE_SHA1;
9865                    salt_type   = SALT_TYPE_EMBEDDED;
9866                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9867                    opts_type   = OPTS_TYPE_PT_GENERATE_BE;
9868                    kern_type   = KERN_TYPE_NETSCALER;
9869                    dgst_size   = DGST_SIZE_4_5;
9870                    parse_func  = netscaler_parse_hash;
9871                    sort_by_digest = sort_by_digest_4_5;
9872                    opti_type   = OPTI_TYPE_ZERO_BYTE
9873                                | OPTI_TYPE_PRECOMPUTE_INIT
9874                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9875                                | OPTI_TYPE_EARLY_SKIP
9876                                | OPTI_TYPE_NOT_ITERATED
9877                                | OPTI_TYPE_PREPENDED_SALT
9878                                | OPTI_TYPE_RAW_HASH;
9879                    dgst_pos0   = 3;
9880                    dgst_pos1   = 4;
9881                    dgst_pos2   = 2;
9882                    dgst_pos3   = 1;
9883                    break;
9884
9885       case  8200:  hash_type   = HASH_TYPE_SHA256;
9886                    salt_type   = SALT_TYPE_EMBEDDED;
9887                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9888                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9889                    kern_type   = KERN_TYPE_CLOUDKEY;
9890                    dgst_size   = DGST_SIZE_4_8;
9891                    parse_func  = cloudkey_parse_hash;
9892                    sort_by_digest = sort_by_digest_4_8;
9893                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9894                    dgst_pos0   = 0;
9895                    dgst_pos1   = 1;
9896                    dgst_pos2   = 2;
9897                    dgst_pos3   = 3;
9898                    break;
9899
9900       case  8300:  hash_type   = HASH_TYPE_SHA1;
9901                    salt_type   = SALT_TYPE_EMBEDDED;
9902                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9904                                | OPTS_TYPE_ST_HEX
9905                                | OPTS_TYPE_ST_ADD80;
9906                    kern_type   = KERN_TYPE_NSEC3;
9907                    dgst_size   = DGST_SIZE_4_5;
9908                    parse_func  = nsec3_parse_hash;
9909                    sort_by_digest = sort_by_digest_4_5;
9910                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9911                    dgst_pos0   = 3;
9912                    dgst_pos1   = 4;
9913                    dgst_pos2   = 2;
9914                    dgst_pos3   = 1;
9915                    break;
9916
9917       case  8400:  hash_type   = HASH_TYPE_SHA1;
9918                    salt_type   = SALT_TYPE_INTERN;
9919                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9920                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9921                                | OPTS_TYPE_PT_ADD80
9922                                | OPTS_TYPE_PT_ADDBITS15;
9923                    kern_type   = KERN_TYPE_WBB3;
9924                    dgst_size   = DGST_SIZE_4_5;
9925                    parse_func  = wbb3_parse_hash;
9926                    sort_by_digest = sort_by_digest_4_5;
9927                    opti_type   = OPTI_TYPE_ZERO_BYTE
9928                                | OPTI_TYPE_PRECOMPUTE_INIT
9929                                | OPTI_TYPE_NOT_ITERATED;
9930                    dgst_pos0   = 3;
9931                    dgst_pos1   = 4;
9932                    dgst_pos2   = 2;
9933                    dgst_pos3   = 1;
9934                    break;
9935
9936       case  8500:  hash_type   = HASH_TYPE_DESRACF;
9937                    salt_type   = SALT_TYPE_EMBEDDED;
9938                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9939                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9940                                | OPTS_TYPE_ST_UPPER;
9941                    kern_type   = KERN_TYPE_RACF;
9942                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9943                    parse_func  = racf_parse_hash;
9944                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9945                    opti_type   = OPTI_TYPE_ZERO_BYTE
9946                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9947                    dgst_pos0   = 0;
9948                    dgst_pos1   = 1;
9949                    dgst_pos2   = 2;
9950                    dgst_pos3   = 3;
9951                    break;
9952
9953       case  8600:  hash_type   = HASH_TYPE_LOTUS5;
9954                    salt_type   = SALT_TYPE_NONE;
9955                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9956                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9957                    kern_type   = KERN_TYPE_LOTUS5;
9958                    dgst_size   = DGST_SIZE_4_4;
9959                    parse_func  = lotus5_parse_hash;
9960                    sort_by_digest = sort_by_digest_4_4;
9961                    opti_type   = OPTI_TYPE_EARLY_SKIP
9962                                | OPTI_TYPE_NOT_ITERATED
9963                                | OPTI_TYPE_NOT_SALTED
9964                                | OPTI_TYPE_RAW_HASH;
9965                    dgst_pos0   = 0;
9966                    dgst_pos1   = 1;
9967                    dgst_pos2   = 2;
9968                    dgst_pos3   = 3;
9969                    break;
9970
9971       case  8700:  hash_type   = HASH_TYPE_LOTUS6;
9972                    salt_type   = SALT_TYPE_EMBEDDED;
9973                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9974                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9975                    kern_type   = KERN_TYPE_LOTUS6;
9976                    dgst_size   = DGST_SIZE_4_4;
9977                    parse_func  = lotus6_parse_hash;
9978                    sort_by_digest = sort_by_digest_4_4;
9979                    opti_type   = OPTI_TYPE_EARLY_SKIP
9980                                | OPTI_TYPE_NOT_ITERATED
9981                                | OPTI_TYPE_RAW_HASH;
9982                    dgst_pos0   = 0;
9983                    dgst_pos1   = 1;
9984                    dgst_pos2   = 2;
9985                    dgst_pos3   = 3;
9986                    break;
9987
9988       case  8800:  hash_type   = HASH_TYPE_ANDROIDFDE;
9989                    salt_type   = SALT_TYPE_EMBEDDED;
9990                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9991                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9992                    kern_type   = KERN_TYPE_ANDROIDFDE;
9993                    dgst_size   = DGST_SIZE_4_4;
9994                    parse_func  = androidfde_parse_hash;
9995                    sort_by_digest = sort_by_digest_4_4;
9996                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9997                    dgst_pos0   = 0;
9998                    dgst_pos1   = 1;
9999                    dgst_pos2   = 2;
10000                    dgst_pos3   = 3;
10001                    break;
10002
10003       case  8900:  hash_type   = HASH_TYPE_SCRYPT;
10004                    salt_type   = SALT_TYPE_EMBEDDED;
10005                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10007                    kern_type   = KERN_TYPE_SCRYPT;
10008                    dgst_size   = DGST_SIZE_4_8;
10009                    parse_func  = scrypt_parse_hash;
10010                    sort_by_digest = sort_by_digest_4_8;
10011                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10012                    dgst_pos0   = 0;
10013                    dgst_pos1   = 1;
10014                    dgst_pos2   = 2;
10015                    dgst_pos3   = 3;
10016                    break;
10017
10018       case  9000:  hash_type   = HASH_TYPE_SHA1;
10019                    salt_type   = SALT_TYPE_EMBEDDED;
10020                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10021                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10022                                | OPTS_TYPE_ST_GENERATE_LE;
10023                    kern_type   = KERN_TYPE_PSAFE2;
10024                    dgst_size   = DGST_SIZE_4_5;
10025                    parse_func  = psafe2_parse_hash;
10026                    sort_by_digest = sort_by_digest_4_5;
10027                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10028                    dgst_pos0   = 0;
10029                    dgst_pos1   = 1;
10030                    dgst_pos2   = 2;
10031                    dgst_pos3   = 3;
10032                    break;
10033
10034       case  9100:  hash_type   = HASH_TYPE_LOTUS8;
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_LOTUS8;
10039                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10040                    parse_func  = lotus8_parse_hash;
10041                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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  9200:  hash_type   = HASH_TYPE_SHA256;
10050                    salt_type   = SALT_TYPE_EMBEDDED;
10051                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10053                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10054                    dgst_size   = DGST_SIZE_4_32;
10055                    parse_func  = cisco8_parse_hash;
10056                    sort_by_digest = sort_by_digest_4_32;
10057                    opti_type   = OPTI_TYPE_ZERO_BYTE
10058                                | OPTI_TYPE_SLOW_HASH_SIMD;
10059                    dgst_pos0   = 0;
10060                    dgst_pos1   = 1;
10061                    dgst_pos2   = 2;
10062                    dgst_pos3   = 3;
10063                    break;
10064
10065       case  9300:  hash_type   = HASH_TYPE_SCRYPT;
10066                    salt_type   = SALT_TYPE_EMBEDDED;
10067                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10069                    kern_type   = KERN_TYPE_SCRYPT;
10070                    dgst_size   = DGST_SIZE_4_8;
10071                    parse_func  = cisco9_parse_hash;
10072                    sort_by_digest = sort_by_digest_4_8;
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  9400:  hash_type   = HASH_TYPE_OFFICE2007;
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_OFFICE2007;
10085                    dgst_size   = DGST_SIZE_4_4;
10086                    parse_func  = office2007_parse_hash;
10087                    sort_by_digest = sort_by_digest_4_4;
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  9500:  hash_type   = HASH_TYPE_OFFICE2010;
10096                    salt_type   = SALT_TYPE_EMBEDDED;
10097                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10099                    kern_type   = KERN_TYPE_OFFICE2010;
10100                    dgst_size   = DGST_SIZE_4_4;
10101                    parse_func  = office2010_parse_hash;
10102                    sort_by_digest = sort_by_digest_4_4;
10103                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10104                    dgst_pos0   = 0;
10105                    dgst_pos1   = 1;
10106                    dgst_pos2   = 2;
10107                    dgst_pos3   = 3;
10108                    break;
10109
10110       case  9600:  hash_type   = HASH_TYPE_OFFICE2013;
10111                    salt_type   = SALT_TYPE_EMBEDDED;
10112                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10114                    kern_type   = KERN_TYPE_OFFICE2013;
10115                    dgst_size   = DGST_SIZE_4_4;
10116                    parse_func  = office2013_parse_hash;
10117                    sort_by_digest = sort_by_digest_4_4;
10118                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10119                    dgst_pos0   = 0;
10120                    dgst_pos1   = 1;
10121                    dgst_pos2   = 2;
10122                    dgst_pos3   = 3;
10123                    break;
10124
10125       case  9700:  hash_type   = HASH_TYPE_OLDOFFICE01;
10126                    salt_type   = SALT_TYPE_EMBEDDED;
10127                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10129                                | OPTS_TYPE_PT_ADD80
10130                                | OPTS_TYPE_PT_UNICODE;
10131                    kern_type   = KERN_TYPE_OLDOFFICE01;
10132                    dgst_size   = DGST_SIZE_4_4;
10133                    parse_func  = oldoffice01_parse_hash;
10134                    sort_by_digest = sort_by_digest_4_4;
10135                    opti_type   = OPTI_TYPE_ZERO_BYTE
10136                                | OPTI_TYPE_PRECOMPUTE_INIT
10137                                | OPTI_TYPE_NOT_ITERATED;
10138                    dgst_pos0   = 0;
10139                    dgst_pos1   = 1;
10140                    dgst_pos2   = 2;
10141                    dgst_pos3   = 3;
10142                    break;
10143
10144       case  9710:  hash_type   = HASH_TYPE_OLDOFFICE01;
10145                    salt_type   = SALT_TYPE_EMBEDDED;
10146                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10147                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10148                                | OPTS_TYPE_PT_ADD80;
10149                    kern_type   = KERN_TYPE_OLDOFFICE01CM1;
10150                    dgst_size   = DGST_SIZE_4_4;
10151                    parse_func  = oldoffice01cm1_parse_hash;
10152                    sort_by_digest = sort_by_digest_4_4;
10153                    opti_type   = OPTI_TYPE_ZERO_BYTE
10154                                | OPTI_TYPE_PRECOMPUTE_INIT
10155                                | OPTI_TYPE_NOT_ITERATED;
10156                    dgst_pos0   = 0;
10157                    dgst_pos1   = 1;
10158                    dgst_pos2   = 2;
10159                    dgst_pos3   = 3;
10160                    break;
10161
10162       case  9720:  hash_type   = HASH_TYPE_OLDOFFICE01;
10163                    salt_type   = SALT_TYPE_EMBEDDED;
10164                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10166                                | OPTS_TYPE_PT_ADD80
10167                                | OPTS_TYPE_PT_UNICODE
10168                                | OPTS_TYPE_PT_NEVERCRACK;
10169                    kern_type   = KERN_TYPE_OLDOFFICE01CM2;
10170                    dgst_size   = DGST_SIZE_4_4;
10171                    parse_func  = oldoffice01cm2_parse_hash;
10172                    sort_by_digest = sort_by_digest_4_4;
10173                    opti_type   = OPTI_TYPE_ZERO_BYTE
10174                                | OPTI_TYPE_PRECOMPUTE_INIT
10175                                | OPTI_TYPE_NOT_ITERATED;
10176                    dgst_pos0   = 0;
10177                    dgst_pos1   = 1;
10178                    dgst_pos2   = 2;
10179                    dgst_pos3   = 3;
10180                    break;
10181
10182       case  9800:  hash_type   = HASH_TYPE_OLDOFFICE34;
10183                    salt_type   = SALT_TYPE_EMBEDDED;
10184                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10185                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10186                                | OPTS_TYPE_PT_ADD80
10187                                | OPTS_TYPE_PT_UNICODE;
10188                    kern_type   = KERN_TYPE_OLDOFFICE34;
10189                    dgst_size   = DGST_SIZE_4_4;
10190                    parse_func  = oldoffice34_parse_hash;
10191                    sort_by_digest = sort_by_digest_4_4;
10192                    opti_type   = OPTI_TYPE_ZERO_BYTE
10193                                | OPTI_TYPE_PRECOMPUTE_INIT
10194                                | OPTI_TYPE_NOT_ITERATED;
10195                    dgst_pos0   = 0;
10196                    dgst_pos1   = 1;
10197                    dgst_pos2   = 2;
10198                    dgst_pos3   = 3;
10199                    break;
10200
10201       case  9810:  hash_type   = HASH_TYPE_OLDOFFICE34;
10202                    salt_type   = SALT_TYPE_EMBEDDED;
10203                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10204                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10205                    kern_type   = KERN_TYPE_OLDOFFICE34CM1;
10206                    dgst_size   = DGST_SIZE_4_4;
10207                    parse_func  = oldoffice34cm1_parse_hash;
10208                    sort_by_digest = sort_by_digest_4_4;
10209                    opti_type   = OPTI_TYPE_ZERO_BYTE
10210                                | OPTI_TYPE_PRECOMPUTE_INIT
10211                                | OPTI_TYPE_NOT_ITERATED;
10212                    dgst_pos0   = 0;
10213                    dgst_pos1   = 1;
10214                    dgst_pos2   = 2;
10215                    dgst_pos3   = 3;
10216                    break;
10217
10218       case  9820:  hash_type   = HASH_TYPE_OLDOFFICE34;
10219                    salt_type   = SALT_TYPE_EMBEDDED;
10220                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10221                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10222                                | OPTS_TYPE_PT_ADD80
10223                                | OPTS_TYPE_PT_UNICODE
10224                                | OPTS_TYPE_PT_NEVERCRACK;
10225                    kern_type   = KERN_TYPE_OLDOFFICE34CM2;
10226                    dgst_size   = DGST_SIZE_4_4;
10227                    parse_func  = oldoffice34cm2_parse_hash;
10228                    sort_by_digest = sort_by_digest_4_4;
10229                    opti_type   = OPTI_TYPE_ZERO_BYTE
10230                                | OPTI_TYPE_PRECOMPUTE_INIT
10231                                | OPTI_TYPE_NOT_ITERATED;
10232                    dgst_pos0   = 0;
10233                    dgst_pos1   = 1;
10234                    dgst_pos2   = 2;
10235                    dgst_pos3   = 3;
10236                    break;
10237
10238       case  9900:  hash_type   = HASH_TYPE_MD5;
10239                    salt_type   = SALT_TYPE_NONE;
10240                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10241                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10242                    kern_type   = KERN_TYPE_RADMIN2;
10243                    dgst_size   = DGST_SIZE_4_4;
10244                    parse_func  = radmin2_parse_hash;
10245                    sort_by_digest = sort_by_digest_4_4;
10246                    opti_type   = OPTI_TYPE_ZERO_BYTE
10247                                | OPTI_TYPE_PRECOMPUTE_INIT
10248                                | OPTI_TYPE_EARLY_SKIP
10249                                | OPTI_TYPE_NOT_ITERATED
10250                                | OPTI_TYPE_NOT_SALTED;
10251                    dgst_pos0   = 0;
10252                    dgst_pos1   = 3;
10253                    dgst_pos2   = 2;
10254                    dgst_pos3   = 1;
10255                    break;
10256
10257       case 10000:  hash_type   = HASH_TYPE_SHA256;
10258                    salt_type   = SALT_TYPE_EMBEDDED;
10259                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10260                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10261                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10262                    dgst_size   = DGST_SIZE_4_32;
10263                    parse_func  = djangopbkdf2_parse_hash;
10264                    sort_by_digest = sort_by_digest_4_32;
10265                    opti_type   = OPTI_TYPE_ZERO_BYTE
10266                                | OPTI_TYPE_SLOW_HASH_SIMD;
10267                    dgst_pos0   = 0;
10268                    dgst_pos1   = 1;
10269                    dgst_pos2   = 2;
10270                    dgst_pos3   = 3;
10271                    break;
10272
10273       case 10100:  hash_type   = HASH_TYPE_SIPHASH;
10274                    salt_type   = SALT_TYPE_EMBEDDED;
10275                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10276                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10277                    kern_type   = KERN_TYPE_SIPHASH;
10278                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10279                    parse_func  = siphash_parse_hash;
10280                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10281                    opti_type   = OPTI_TYPE_ZERO_BYTE
10282                                | OPTI_TYPE_NOT_ITERATED
10283                                | OPTI_TYPE_RAW_HASH;
10284                    dgst_pos0   = 0;
10285                    dgst_pos1   = 1;
10286                    dgst_pos2   = 2;
10287                    dgst_pos3   = 3;
10288                    break;
10289
10290       case 10200:  hash_type   = HASH_TYPE_MD5;
10291                    salt_type   = SALT_TYPE_EMBEDDED;
10292                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10293                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10294                                | OPTS_TYPE_ST_ADD80
10295                                | OPTS_TYPE_ST_ADDBITS14;
10296                    kern_type   = KERN_TYPE_HMACMD5_PW;
10297                    dgst_size   = DGST_SIZE_4_4;
10298                    parse_func  = crammd5_parse_hash;
10299                    sort_by_digest = sort_by_digest_4_4;
10300                    opti_type   = OPTI_TYPE_ZERO_BYTE
10301                                | OPTI_TYPE_NOT_ITERATED;
10302                    dgst_pos0   = 0;
10303                    dgst_pos1   = 3;
10304                    dgst_pos2   = 2;
10305                    dgst_pos3   = 1;
10306                    break;
10307
10308       case 10300:  hash_type   = HASH_TYPE_SHA1;
10309                    salt_type   = SALT_TYPE_EMBEDDED;
10310                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10311                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10312                    kern_type   = KERN_TYPE_SAPH_SHA1;
10313                    dgst_size   = DGST_SIZE_4_5;
10314                    parse_func  = saph_sha1_parse_hash;
10315                    sort_by_digest = sort_by_digest_4_5;
10316                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10317                    dgst_pos0   = 0;
10318                    dgst_pos1   = 1;
10319                    dgst_pos2   = 2;
10320                    dgst_pos3   = 3;
10321                    break;
10322
10323       case 10400:  hash_type   = HASH_TYPE_PDFU16;
10324                    salt_type   = SALT_TYPE_EMBEDDED;
10325                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10326                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10327                    kern_type   = KERN_TYPE_PDF11;
10328                    dgst_size   = DGST_SIZE_4_4;
10329                    parse_func  = pdf11_parse_hash;
10330                    sort_by_digest = sort_by_digest_4_4;
10331                    opti_type   = OPTI_TYPE_ZERO_BYTE
10332                                | OPTI_TYPE_NOT_ITERATED;
10333                    dgst_pos0   = 0;
10334                    dgst_pos1   = 1;
10335                    dgst_pos2   = 2;
10336                    dgst_pos3   = 3;
10337                    break;
10338
10339       case 10410:  hash_type   = HASH_TYPE_PDFU16;
10340                    salt_type   = SALT_TYPE_EMBEDDED;
10341                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10343                    kern_type   = KERN_TYPE_PDF11CM1;
10344                    dgst_size   = DGST_SIZE_4_4;
10345                    parse_func  = pdf11cm1_parse_hash;
10346                    sort_by_digest = sort_by_digest_4_4;
10347                    opti_type   = OPTI_TYPE_ZERO_BYTE
10348                                | OPTI_TYPE_NOT_ITERATED;
10349                    dgst_pos0   = 0;
10350                    dgst_pos1   = 1;
10351                    dgst_pos2   = 2;
10352                    dgst_pos3   = 3;
10353                    break;
10354
10355       case 10420:  hash_type   = HASH_TYPE_PDFU16;
10356                    salt_type   = SALT_TYPE_EMBEDDED;
10357                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10358                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10359                    kern_type   = KERN_TYPE_PDF11CM2;
10360                    dgst_size   = DGST_SIZE_4_4;
10361                    parse_func  = pdf11cm2_parse_hash;
10362                    sort_by_digest = sort_by_digest_4_4;
10363                    opti_type   = OPTI_TYPE_ZERO_BYTE
10364                                | OPTI_TYPE_NOT_ITERATED;
10365                    dgst_pos0   = 0;
10366                    dgst_pos1   = 1;
10367                    dgst_pos2   = 2;
10368                    dgst_pos3   = 3;
10369                    break;
10370
10371       case 10500:  hash_type   = HASH_TYPE_PDFU16;
10372                    salt_type   = SALT_TYPE_EMBEDDED;
10373                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10374                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10375                    kern_type   = KERN_TYPE_PDF14;
10376                    dgst_size   = DGST_SIZE_4_4;
10377                    parse_func  = pdf14_parse_hash;
10378                    sort_by_digest = sort_by_digest_4_4;
10379                    opti_type   = OPTI_TYPE_ZERO_BYTE
10380                                | OPTI_TYPE_NOT_ITERATED;
10381                    dgst_pos0   = 0;
10382                    dgst_pos1   = 1;
10383                    dgst_pos2   = 2;
10384                    dgst_pos3   = 3;
10385                    break;
10386
10387       case 10600:  hash_type   = HASH_TYPE_SHA256;
10388                    salt_type   = SALT_TYPE_EMBEDDED;
10389                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10390                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10391                                | OPTS_TYPE_ST_ADD80
10392                                | OPTS_TYPE_ST_ADDBITS15
10393                                | OPTS_TYPE_HASH_COPY;
10394                    kern_type   = KERN_TYPE_SHA256_PWSLT;
10395                    dgst_size   = DGST_SIZE_4_8;
10396                    parse_func  = pdf17l3_parse_hash;
10397                    sort_by_digest = sort_by_digest_4_8;
10398                    opti_type   = OPTI_TYPE_ZERO_BYTE
10399                                | OPTI_TYPE_PRECOMPUTE_INIT
10400                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10401                                | OPTI_TYPE_EARLY_SKIP
10402                                | OPTI_TYPE_NOT_ITERATED
10403                                | OPTI_TYPE_APPENDED_SALT
10404                                | OPTI_TYPE_RAW_HASH;
10405                    dgst_pos0   = 3;
10406                    dgst_pos1   = 7;
10407                    dgst_pos2   = 2;
10408                    dgst_pos3   = 6;
10409                    break;
10410
10411       case 10700:  hash_type   = HASH_TYPE_PDFU32;
10412                    salt_type   = SALT_TYPE_EMBEDDED;
10413                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10414                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10415                                | OPTS_TYPE_HASH_COPY;
10416                    kern_type   = KERN_TYPE_PDF17L8;
10417                    dgst_size   = DGST_SIZE_4_8;
10418                    parse_func  = pdf17l8_parse_hash;
10419                    sort_by_digest = sort_by_digest_4_8;
10420                    opti_type   = OPTI_TYPE_ZERO_BYTE
10421                                | OPTI_TYPE_NOT_ITERATED;
10422                    dgst_pos0   = 0;
10423                    dgst_pos1   = 1;
10424                    dgst_pos2   = 2;
10425                    dgst_pos3   = 3;
10426                    break;
10427
10428       case 10800:  hash_type   = HASH_TYPE_SHA384;
10429                    salt_type   = SALT_TYPE_NONE;
10430                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10431                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10432                                | OPTS_TYPE_PT_ADD80
10433                                | OPTS_TYPE_PT_ADDBITS15;
10434                    kern_type   = KERN_TYPE_SHA384;
10435                    dgst_size   = DGST_SIZE_8_8;
10436                    parse_func  = sha384_parse_hash;
10437                    sort_by_digest = sort_by_digest_8_8;
10438                    opti_type   = OPTI_TYPE_ZERO_BYTE
10439                                | OPTI_TYPE_PRECOMPUTE_INIT
10440                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10441                                | OPTI_TYPE_EARLY_SKIP
10442                                | OPTI_TYPE_NOT_ITERATED
10443                                | OPTI_TYPE_NOT_SALTED
10444                                | OPTI_TYPE_USES_BITS_64
10445                                | OPTI_TYPE_RAW_HASH;
10446                    dgst_pos0   = 6;
10447                    dgst_pos1   = 7;
10448                    dgst_pos2   = 4;
10449                    dgst_pos3   = 5;
10450                    break;
10451
10452       case 10900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10453                    salt_type   = SALT_TYPE_EMBEDDED;
10454                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10455                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10456                                | OPTS_TYPE_ST_BASE64
10457                                | OPTS_TYPE_HASH_COPY;
10458                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10459                    dgst_size   = DGST_SIZE_4_32;
10460                    parse_func  = pbkdf2_sha256_parse_hash;
10461                    sort_by_digest = sort_by_digest_4_32;
10462                    opti_type   = OPTI_TYPE_ZERO_BYTE
10463                                | OPTI_TYPE_SLOW_HASH_SIMD;
10464                    dgst_pos0   = 0;
10465                    dgst_pos1   = 1;
10466                    dgst_pos2   = 2;
10467                    dgst_pos3   = 3;
10468                    break;
10469
10470       case 11000:  hash_type   = HASH_TYPE_MD5;
10471                    salt_type   = SALT_TYPE_INTERN;
10472                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10473                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10474                                | OPTS_TYPE_PT_ADD80;
10475                    kern_type   = KERN_TYPE_PRESTASHOP;
10476                    dgst_size   = DGST_SIZE_4_4;
10477                    parse_func  = prestashop_parse_hash;
10478                    sort_by_digest = sort_by_digest_4_4;
10479                    opti_type   = OPTI_TYPE_ZERO_BYTE
10480                                | OPTI_TYPE_PRECOMPUTE_INIT
10481                                | OPTI_TYPE_NOT_ITERATED
10482                                | OPTI_TYPE_PREPENDED_SALT;
10483                    dgst_pos0   = 0;
10484                    dgst_pos1   = 3;
10485                    dgst_pos2   = 2;
10486                    dgst_pos3   = 1;
10487                    break;
10488
10489       case 11100:  hash_type   = HASH_TYPE_MD5;
10490                    salt_type   = SALT_TYPE_EMBEDDED;
10491                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10492                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10493                                | OPTS_TYPE_ST_ADD80;
10494                    kern_type   = KERN_TYPE_POSTGRESQL_AUTH;
10495                    dgst_size   = DGST_SIZE_4_4;
10496                    parse_func  = postgresql_auth_parse_hash;
10497                    sort_by_digest = sort_by_digest_4_4;
10498                    opti_type   = OPTI_TYPE_ZERO_BYTE
10499                                | OPTI_TYPE_PRECOMPUTE_INIT
10500                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10501                                | OPTI_TYPE_EARLY_SKIP;
10502                    dgst_pos0   = 0;
10503                    dgst_pos1   = 3;
10504                    dgst_pos2   = 2;
10505                    dgst_pos3   = 1;
10506                    break;
10507
10508       case 11200:  hash_type   = HASH_TYPE_SHA1;
10509                    salt_type   = SALT_TYPE_EMBEDDED;
10510                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10511                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10512                                | OPTS_TYPE_PT_ADD80
10513                                | OPTS_TYPE_ST_HEX;
10514                    kern_type   = KERN_TYPE_MYSQL_AUTH;
10515                    dgst_size   = DGST_SIZE_4_5;
10516                    parse_func  = mysql_auth_parse_hash;
10517                    sort_by_digest = sort_by_digest_4_5;
10518                    opti_type   = OPTI_TYPE_ZERO_BYTE
10519                                | OPTI_TYPE_EARLY_SKIP;
10520                    dgst_pos0   = 3;
10521                    dgst_pos1   = 4;
10522                    dgst_pos2   = 2;
10523                    dgst_pos3   = 1;
10524                    break;
10525
10526       case 11300:  hash_type   = HASH_TYPE_BITCOIN_WALLET;
10527                    salt_type   = SALT_TYPE_EMBEDDED;
10528                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10529                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10530                                | OPTS_TYPE_ST_HEX
10531                                | OPTS_TYPE_ST_ADD80;
10532                    kern_type   = KERN_TYPE_BITCOIN_WALLET;
10533                    dgst_size   = DGST_SIZE_4_4;
10534                    parse_func  = bitcoin_wallet_parse_hash;
10535                    sort_by_digest = sort_by_digest_4_4;
10536                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10537                    dgst_pos0   = 0;
10538                    dgst_pos1   = 1;
10539                    dgst_pos2   = 2;
10540                    dgst_pos3   = 3;
10541                    break;
10542
10543       case 11400:  hash_type   = HASH_TYPE_MD5;
10544                    salt_type   = SALT_TYPE_EMBEDDED;
10545                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10546                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10547                                | OPTS_TYPE_PT_ADD80
10548                                | OPTS_TYPE_HASH_COPY;
10549                    kern_type   = KERN_TYPE_SIP_AUTH;
10550                    dgst_size   = DGST_SIZE_4_4;
10551                    parse_func  = sip_auth_parse_hash;
10552                    sort_by_digest = sort_by_digest_4_4;
10553                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10554                    dgst_pos0   = 0;
10555                    dgst_pos1   = 3;
10556                    dgst_pos2   = 2;
10557                    dgst_pos3   = 1;
10558                    break;
10559
10560       case 11500:  hash_type   = HASH_TYPE_CRC32;
10561                    salt_type   = SALT_TYPE_INTERN;
10562                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10563                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10564                                | OPTS_TYPE_ST_GENERATE_LE
10565                                | OPTS_TYPE_ST_HEX;
10566                    kern_type   = KERN_TYPE_CRC32;
10567                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10568                    parse_func  = crc32_parse_hash;
10569                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10570                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10571                    dgst_pos0   = 0;
10572                    dgst_pos1   = 1;
10573                    dgst_pos2   = 2;
10574                    dgst_pos3   = 3;
10575                    break;
10576
10577       case 11600:  hash_type   = HASH_TYPE_AES;
10578                    salt_type   = SALT_TYPE_EMBEDDED;
10579                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10580                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10581                                | OPTS_TYPE_PT_NEVERCRACK;
10582                    kern_type   = KERN_TYPE_SEVEN_ZIP;
10583                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10584                    parse_func  = seven_zip_parse_hash;
10585                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10586                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10587                    dgst_pos0   = 0;
10588                    dgst_pos1   = 1;
10589                    dgst_pos2   = 2;
10590                    dgst_pos3   = 3;
10591                    break;
10592
10593       case 11700:  hash_type   = HASH_TYPE_GOST_2012SBOG_256;
10594                    salt_type   = SALT_TYPE_NONE;
10595                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10596                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10597                                | OPTS_TYPE_PT_ADD01;
10598                    kern_type   = KERN_TYPE_GOST_2012SBOG_256;
10599                    dgst_size   = DGST_SIZE_4_8;
10600                    parse_func  = gost2012sbog_256_parse_hash;
10601                    sort_by_digest = sort_by_digest_4_8;
10602                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10603                    dgst_pos0   = 0;
10604                    dgst_pos1   = 1;
10605                    dgst_pos2   = 2;
10606                    dgst_pos3   = 3;
10607                    break;
10608
10609       case 11800:  hash_type   = HASH_TYPE_GOST_2012SBOG_512;
10610                    salt_type   = SALT_TYPE_NONE;
10611                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10612                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10613                                | OPTS_TYPE_PT_ADD01;
10614                    kern_type   = KERN_TYPE_GOST_2012SBOG_512;
10615                    dgst_size   = DGST_SIZE_4_16;
10616                    parse_func  = gost2012sbog_512_parse_hash;
10617                    sort_by_digest = sort_by_digest_4_16;
10618                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10619                    dgst_pos0   = 0;
10620                    dgst_pos1   = 1;
10621                    dgst_pos2   = 2;
10622                    dgst_pos3   = 3;
10623                    break;
10624
10625       case 11900:  hash_type   = HASH_TYPE_PBKDF2_MD5;
10626                    salt_type   = SALT_TYPE_EMBEDDED;
10627                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10628                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10629                                | OPTS_TYPE_ST_BASE64
10630                                | OPTS_TYPE_HASH_COPY;
10631                    kern_type   = KERN_TYPE_PBKDF2_MD5;
10632                    dgst_size   = DGST_SIZE_4_32;
10633                    parse_func  = pbkdf2_md5_parse_hash;
10634                    sort_by_digest = sort_by_digest_4_32;
10635                    opti_type   = OPTI_TYPE_ZERO_BYTE
10636                                | OPTI_TYPE_SLOW_HASH_SIMD;
10637                    dgst_pos0   = 0;
10638                    dgst_pos1   = 1;
10639                    dgst_pos2   = 2;
10640                    dgst_pos3   = 3;
10641                    break;
10642
10643       case 12000:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
10644                    salt_type   = SALT_TYPE_EMBEDDED;
10645                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10646                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10647                                | OPTS_TYPE_ST_BASE64
10648                                | OPTS_TYPE_HASH_COPY;
10649                    kern_type   = KERN_TYPE_PBKDF2_SHA1;
10650                    dgst_size   = DGST_SIZE_4_32;
10651                    parse_func  = pbkdf2_sha1_parse_hash;
10652                    sort_by_digest = sort_by_digest_4_32;
10653                    opti_type   = OPTI_TYPE_ZERO_BYTE
10654                                | OPTI_TYPE_SLOW_HASH_SIMD;
10655                    dgst_pos0   = 0;
10656                    dgst_pos1   = 1;
10657                    dgst_pos2   = 2;
10658                    dgst_pos3   = 3;
10659                    break;
10660
10661       case 12100:  hash_type   = HASH_TYPE_PBKDF2_SHA512;
10662                    salt_type   = SALT_TYPE_EMBEDDED;
10663                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10664                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10665                                | OPTS_TYPE_ST_BASE64
10666                                | OPTS_TYPE_HASH_COPY;
10667                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
10668                    dgst_size   = DGST_SIZE_8_16;
10669                    parse_func  = pbkdf2_sha512_parse_hash;
10670                    sort_by_digest = sort_by_digest_8_16;
10671                    opti_type   = OPTI_TYPE_ZERO_BYTE
10672                                | OPTI_TYPE_USES_BITS_64
10673                                | OPTI_TYPE_SLOW_HASH_SIMD;
10674                    dgst_pos0   = 0;
10675                    dgst_pos1   = 1;
10676                    dgst_pos2   = 2;
10677                    dgst_pos3   = 3;
10678                    break;
10679
10680       case 12200:  hash_type   = HASH_TYPE_ECRYPTFS;
10681                    salt_type   = SALT_TYPE_EMBEDDED;
10682                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10683                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10684                    kern_type   = KERN_TYPE_ECRYPTFS;
10685                    dgst_size   = DGST_SIZE_8_8;
10686                    parse_func  = ecryptfs_parse_hash;
10687                    sort_by_digest = sort_by_digest_8_8;
10688                    opti_type   = OPTI_TYPE_ZERO_BYTE
10689                                | OPTI_TYPE_USES_BITS_64;
10690                    dgst_pos0   = 0;
10691                    dgst_pos1   = 1;
10692                    dgst_pos2   = 2;
10693                    dgst_pos3   = 3;
10694                    break;
10695
10696       case 12300:  hash_type   = HASH_TYPE_ORACLET;
10697                    salt_type   = SALT_TYPE_EMBEDDED;
10698                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10700                    kern_type   = KERN_TYPE_ORACLET;
10701                    dgst_size   = DGST_SIZE_8_16;
10702                    parse_func  = oraclet_parse_hash;
10703                    sort_by_digest = sort_by_digest_8_16;
10704                    opti_type   = OPTI_TYPE_ZERO_BYTE
10705                                | OPTI_TYPE_USES_BITS_64;
10706                    dgst_pos0   = 0;
10707                    dgst_pos1   = 1;
10708                    dgst_pos2   = 2;
10709                    dgst_pos3   = 3;
10710                    break;
10711
10712       case 12400:  hash_type   = HASH_TYPE_BSDICRYPT;
10713                    salt_type   = SALT_TYPE_EMBEDDED;
10714                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10716                    kern_type   = KERN_TYPE_BSDICRYPT;
10717                    dgst_size   = DGST_SIZE_4_4;
10718                    parse_func  = bsdicrypt_parse_hash;
10719                    sort_by_digest = sort_by_digest_4_4;
10720                    opti_type   = OPTI_TYPE_ZERO_BYTE
10721                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
10722                    dgst_pos0   = 0;
10723                    dgst_pos1   = 1;
10724                    dgst_pos2   = 2;
10725                    dgst_pos3   = 3;
10726                    break;
10727
10728       case 12500:  hash_type   = HASH_TYPE_RAR3HP;
10729                    salt_type   = SALT_TYPE_EMBEDDED;
10730                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10731                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10732                    kern_type   = KERN_TYPE_RAR3;
10733                    dgst_size   = DGST_SIZE_4_4;
10734                    parse_func  = rar3hp_parse_hash;
10735                    sort_by_digest = sort_by_digest_4_4;
10736                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10737                    dgst_pos0   = 0;
10738                    dgst_pos1   = 1;
10739                    dgst_pos2   = 2;
10740                    dgst_pos3   = 3;
10741                    break;
10742
10743       case 12600:  hash_type   = HASH_TYPE_SHA256;
10744                    salt_type   = SALT_TYPE_INTERN;
10745                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10746                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10747                                | OPTS_TYPE_PT_ADD80;
10748                    kern_type   = KERN_TYPE_CF10;
10749                    dgst_size   = DGST_SIZE_4_8;
10750                    parse_func  = cf10_parse_hash;
10751                    sort_by_digest = sort_by_digest_4_8;
10752                    opti_type   = OPTI_TYPE_ZERO_BYTE
10753                                | OPTI_TYPE_PRECOMPUTE_INIT
10754                                | OPTI_TYPE_EARLY_SKIP
10755                                | OPTI_TYPE_NOT_ITERATED;
10756                    dgst_pos0   = 3;
10757                    dgst_pos1   = 7;
10758                    dgst_pos2   = 2;
10759                    dgst_pos3   = 6;
10760                    break;
10761
10762       case 12700:  hash_type   = HASH_TYPE_AES;
10763                    salt_type   = SALT_TYPE_EMBEDDED;
10764                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10765                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10766                                | OPTS_TYPE_HASH_COPY;
10767                    kern_type   = KERN_TYPE_MYWALLET;
10768                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
10769                    parse_func  = mywallet_parse_hash;
10770                    sort_by_digest = sort_by_digest_4_5;
10771                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10772                    dgst_pos0   = 0;
10773                    dgst_pos1   = 1;
10774                    dgst_pos2   = 2;
10775                    dgst_pos3   = 3;
10776                    break;
10777
10778       case 12800:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10779                    salt_type   = SALT_TYPE_EMBEDDED;
10780                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10781                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10782                    kern_type   = KERN_TYPE_MS_DRSR;
10783                    dgst_size   = DGST_SIZE_4_8;
10784                    parse_func  = ms_drsr_parse_hash;
10785                    sort_by_digest = sort_by_digest_4_8;
10786                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10787                    dgst_pos0   = 0;
10788                    dgst_pos1   = 1;
10789                    dgst_pos2   = 2;
10790                    dgst_pos3   = 3;
10791                    break;
10792
10793       case 12900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10794                    salt_type   = SALT_TYPE_EMBEDDED;
10795                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10796                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10797                    kern_type   = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10798                    dgst_size   = DGST_SIZE_4_8;
10799                    parse_func  = androidfde_samsung_parse_hash;
10800                    sort_by_digest = sort_by_digest_4_8;
10801                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10802                    dgst_pos0   = 0;
10803                    dgst_pos1   = 1;
10804                    dgst_pos2   = 2;
10805                    dgst_pos3   = 3;
10806                    break;
10807
10808       case 13000:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10809                    salt_type   = SALT_TYPE_EMBEDDED;
10810                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10811                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10812                    kern_type   = KERN_TYPE_RAR5;
10813                    dgst_size   = DGST_SIZE_4_4;
10814                    parse_func  = rar5_parse_hash;
10815                    sort_by_digest = sort_by_digest_4_4;
10816                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10817                    dgst_pos0   = 0;
10818                    dgst_pos1   = 1;
10819                    dgst_pos2   = 2;
10820                    dgst_pos3   = 3;
10821                    break;
10822
10823       case 13100:  hash_type   = HASH_TYPE_KRB5TGS;
10824                    salt_type   = SALT_TYPE_EMBEDDED;
10825                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10826                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10827                    kern_type   = KERN_TYPE_KRB5TGS;
10828                    dgst_size   = DGST_SIZE_4_4;
10829                    parse_func  = krb5tgs_parse_hash;
10830                    sort_by_digest = sort_by_digest_4_4;
10831                    opti_type   = OPTI_TYPE_ZERO_BYTE
10832                                | OPTI_TYPE_NOT_ITERATED;
10833                    dgst_pos0   = 0;
10834                    dgst_pos1   = 1;
10835                    dgst_pos2   = 2;
10836                    dgst_pos3   = 3;
10837                    break;
10838
10839       case 13200:  hash_type   = HASH_TYPE_AES;
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_AXCRYPT;
10844                    dgst_size   = DGST_SIZE_4_4;
10845                    parse_func  = axcrypt_parse_hash;
10846                    sort_by_digest = sort_by_digest_4_4;
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 13300:  hash_type   = HASH_TYPE_SHA1;
10855                    salt_type   = SALT_TYPE_NONE;
10856                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10857                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10858                                | OPTS_TYPE_PT_ADD80
10859                                | OPTS_TYPE_PT_ADDBITS15;
10860                    kern_type   = KERN_TYPE_SHA1_AXCRYPT;
10861                    dgst_size   = DGST_SIZE_4_5;
10862                    parse_func  = sha1axcrypt_parse_hash;
10863                    sort_by_digest = sort_by_digest_4_5;
10864                    opti_type   = OPTI_TYPE_ZERO_BYTE
10865                                | OPTI_TYPE_PRECOMPUTE_INIT
10866                                | OPTI_TYPE_EARLY_SKIP
10867                                | OPTI_TYPE_NOT_ITERATED
10868                                | OPTI_TYPE_NOT_SALTED;
10869                    dgst_pos0   = 0;
10870                    dgst_pos1   = 4;
10871                    dgst_pos2   = 3;
10872                    dgst_pos3   = 2;
10873                    break;
10874
10875       case 13400:  hash_type   = HASH_TYPE_AES;
10876                    salt_type   = SALT_TYPE_EMBEDDED;
10877                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10878                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10879                    kern_type   = KERN_TYPE_KEEPASS;
10880                    dgst_size   = DGST_SIZE_4_4;
10881                    parse_func  = keepass_parse_hash;
10882                    sort_by_digest = sort_by_digest_4_4;
10883                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10884                    dgst_pos0   = 0;
10885                    dgst_pos1   = 1;
10886                    dgst_pos2   = 2;
10887                    dgst_pos3   = 3;
10888                    break;
10889
10890       case 13500:  hash_type   = HASH_TYPE_SHA1;
10891                    salt_type   = SALT_TYPE_EMBEDDED;
10892                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10893                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10894                                | OPTS_TYPE_PT_UNICODE
10895                                | OPTS_TYPE_PT_ADD80;
10896                    kern_type   = KERN_TYPE_PSTOKEN;
10897                    dgst_size   = DGST_SIZE_4_5;
10898                    parse_func  = pstoken_parse_hash;
10899                    sort_by_digest = sort_by_digest_4_5;
10900                    opti_type   = OPTI_TYPE_ZERO_BYTE
10901                                | OPTI_TYPE_PRECOMPUTE_INIT
10902                                | OPTI_TYPE_EARLY_SKIP
10903                                | OPTI_TYPE_NOT_ITERATED
10904                                | OPTI_TYPE_PREPENDED_SALT
10905                                | OPTI_TYPE_RAW_HASH;
10906                    dgst_pos0   = 3;
10907                    dgst_pos1   = 4;
10908                    dgst_pos2   = 2;
10909                    dgst_pos3   = 1;
10910                    break;
10911
10912       case 13600:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
10913                    salt_type   = SALT_TYPE_EMBEDDED;
10914                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10915                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10916                    kern_type   = KERN_TYPE_ZIP2;
10917                    dgst_size   = DGST_SIZE_4_4;
10918                    parse_func  = zip2_parse_hash;
10919                    sort_by_digest = sort_by_digest_4_4;
10920                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10921                    dgst_pos0   = 0;
10922                    dgst_pos1   = 1;
10923                    dgst_pos2   = 2;
10924                    dgst_pos3   = 3;
10925                    break;
10926
10927       case 13711:  hash_type   = HASH_TYPE_RIPEMD160;
10928                    salt_type   = SALT_TYPE_EMBEDDED;
10929                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10930                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10931                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
10932                    dgst_size   = DGST_SIZE_4_5;
10933                    parse_func  = veracrypt_parse_hash_655331;
10934                    sort_by_digest = sort_by_digest_4_5;
10935                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10936                    dgst_pos0   = 0;
10937                    dgst_pos1   = 1;
10938                    dgst_pos2   = 2;
10939                    dgst_pos3   = 3;
10940                    break;
10941
10942       case 13712:  hash_type   = HASH_TYPE_RIPEMD160;
10943                    salt_type   = SALT_TYPE_EMBEDDED;
10944                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10945                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10946                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
10947                    dgst_size   = DGST_SIZE_4_5;
10948                    parse_func  = veracrypt_parse_hash_655331;
10949                    sort_by_digest = sort_by_digest_4_5;
10950                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10951                    dgst_pos0   = 0;
10952                    dgst_pos1   = 1;
10953                    dgst_pos2   = 2;
10954                    dgst_pos3   = 3;
10955                    break;
10956
10957       case 13713:  hash_type   = HASH_TYPE_RIPEMD160;
10958                    salt_type   = SALT_TYPE_EMBEDDED;
10959                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10960                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10961                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
10962                    dgst_size   = DGST_SIZE_4_5;
10963                    parse_func  = veracrypt_parse_hash_655331;
10964                    sort_by_digest = sort_by_digest_4_5;
10965                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10966                    dgst_pos0   = 0;
10967                    dgst_pos1   = 1;
10968                    dgst_pos2   = 2;
10969                    dgst_pos3   = 3;
10970                    break;
10971
10972       case 13721:  hash_type   = HASH_TYPE_SHA512;
10973                    salt_type   = SALT_TYPE_EMBEDDED;
10974                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10975                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10976                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
10977                    dgst_size   = DGST_SIZE_8_8;
10978                    parse_func  = veracrypt_parse_hash_500000;
10979                    sort_by_digest = sort_by_digest_8_8;
10980                    opti_type   = OPTI_TYPE_ZERO_BYTE
10981                                | OPTI_TYPE_USES_BITS_64;
10982                    dgst_pos0   = 0;
10983                    dgst_pos1   = 1;
10984                    dgst_pos2   = 2;
10985                    dgst_pos3   = 3;
10986                    break;
10987
10988       case 13722:  hash_type   = HASH_TYPE_SHA512;
10989                    salt_type   = SALT_TYPE_EMBEDDED;
10990                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10991                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10992                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
10993                    dgst_size   = DGST_SIZE_8_8;
10994                    parse_func  = veracrypt_parse_hash_500000;
10995                    sort_by_digest = sort_by_digest_8_8;
10996                    opti_type   = OPTI_TYPE_ZERO_BYTE
10997                                | OPTI_TYPE_USES_BITS_64;
10998                    dgst_pos0   = 0;
10999                    dgst_pos1   = 1;
11000                    dgst_pos2   = 2;
11001                    dgst_pos3   = 3;
11002                    break;
11003
11004       case 13723:  hash_type   = HASH_TYPE_SHA512;
11005                    salt_type   = SALT_TYPE_EMBEDDED;
11006                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11007                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11008                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
11009                    dgst_size   = DGST_SIZE_8_8;
11010                    parse_func  = veracrypt_parse_hash_500000;
11011                    sort_by_digest = sort_by_digest_8_8;
11012                    opti_type   = OPTI_TYPE_ZERO_BYTE
11013                                | OPTI_TYPE_USES_BITS_64;
11014                    dgst_pos0   = 0;
11015                    dgst_pos1   = 1;
11016                    dgst_pos2   = 2;
11017                    dgst_pos3   = 3;
11018                    break;
11019
11020       case 13731:  hash_type   = HASH_TYPE_WHIRLPOOL;
11021                    salt_type   = SALT_TYPE_EMBEDDED;
11022                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11023                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11024                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
11025                    dgst_size   = DGST_SIZE_4_8;
11026                    parse_func  = veracrypt_parse_hash_500000;
11027                    sort_by_digest = sort_by_digest_4_8;
11028                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11029                    dgst_pos0   = 0;
11030                    dgst_pos1   = 1;
11031                    dgst_pos2   = 2;
11032                    dgst_pos3   = 3;
11033                    break;
11034
11035       case 13732:  hash_type   = HASH_TYPE_WHIRLPOOL;
11036                    salt_type   = SALT_TYPE_EMBEDDED;
11037                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11038                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11039                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11040                    dgst_size   = DGST_SIZE_4_8;
11041                    parse_func  = veracrypt_parse_hash_500000;
11042                    sort_by_digest = sort_by_digest_4_8;
11043                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11044                    dgst_pos0   = 0;
11045                    dgst_pos1   = 1;
11046                    dgst_pos2   = 2;
11047                    dgst_pos3   = 3;
11048                    break;
11049
11050       case 13733:  hash_type   = HASH_TYPE_WHIRLPOOL;
11051                    salt_type   = SALT_TYPE_EMBEDDED;
11052                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11053                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11054                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11055                    dgst_size   = DGST_SIZE_4_8;
11056                    parse_func  = veracrypt_parse_hash_500000;
11057                    sort_by_digest = sort_by_digest_4_8;
11058                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11059                    dgst_pos0   = 0;
11060                    dgst_pos1   = 1;
11061                    dgst_pos2   = 2;
11062                    dgst_pos3   = 3;
11063                    break;
11064
11065       case 13741:  hash_type   = HASH_TYPE_RIPEMD160;
11066                    salt_type   = SALT_TYPE_EMBEDDED;
11067                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11068                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11069                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
11070                    dgst_size   = DGST_SIZE_4_5;
11071                    parse_func  = veracrypt_parse_hash_327661;
11072                    sort_by_digest = sort_by_digest_4_5;
11073                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11074                    dgst_pos0   = 0;
11075                    dgst_pos1   = 1;
11076                    dgst_pos2   = 2;
11077                    dgst_pos3   = 3;
11078                    break;
11079
11080       case 13742:  hash_type   = HASH_TYPE_RIPEMD160;
11081                    salt_type   = SALT_TYPE_EMBEDDED;
11082                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11083                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11084                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
11085                    dgst_size   = DGST_SIZE_4_5;
11086                    parse_func  = veracrypt_parse_hash_327661;
11087                    sort_by_digest = sort_by_digest_4_5;
11088                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11089                    dgst_pos0   = 0;
11090                    dgst_pos1   = 1;
11091                    dgst_pos2   = 2;
11092                    dgst_pos3   = 3;
11093                    break;
11094
11095       case 13743:  hash_type   = HASH_TYPE_RIPEMD160;
11096                    salt_type   = SALT_TYPE_EMBEDDED;
11097                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11098                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11099                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
11100                    dgst_size   = DGST_SIZE_4_5;
11101                    parse_func  = veracrypt_parse_hash_327661;
11102                    sort_by_digest = sort_by_digest_4_5;
11103                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11104                    dgst_pos0   = 0;
11105                    dgst_pos1   = 1;
11106                    dgst_pos2   = 2;
11107                    dgst_pos3   = 3;
11108                    break;
11109
11110       case 13751:  hash_type   = HASH_TYPE_SHA256;
11111                    salt_type   = SALT_TYPE_EMBEDDED;
11112                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11113                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11114                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11115                    dgst_size   = DGST_SIZE_4_8;
11116                    parse_func  = veracrypt_parse_hash_500000;
11117                    sort_by_digest = sort_by_digest_4_8;
11118                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11119                    dgst_pos0   = 0;
11120                    dgst_pos1   = 1;
11121                    dgst_pos2   = 2;
11122                    dgst_pos3   = 3;
11123                    break;
11124
11125       case 13752:  hash_type   = HASH_TYPE_SHA256;
11126                    salt_type   = SALT_TYPE_EMBEDDED;
11127                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11128                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11129                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11130                    dgst_size   = DGST_SIZE_4_8;
11131                    parse_func  = veracrypt_parse_hash_500000;
11132                    sort_by_digest = sort_by_digest_4_8;
11133                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11134                    dgst_pos0   = 0;
11135                    dgst_pos1   = 1;
11136                    dgst_pos2   = 2;
11137                    dgst_pos3   = 3;
11138                    break;
11139
11140       case 13753:  hash_type   = HASH_TYPE_SHA256;
11141                    salt_type   = SALT_TYPE_EMBEDDED;
11142                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11143                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11144                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11145                    dgst_size   = DGST_SIZE_4_8;
11146                    parse_func  = veracrypt_parse_hash_500000;
11147                    sort_by_digest = sort_by_digest_4_8;
11148                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11149                    dgst_pos0   = 0;
11150                    dgst_pos1   = 1;
11151                    dgst_pos2   = 2;
11152                    dgst_pos3   = 3;
11153                    break;
11154
11155       case 13761:  hash_type   = HASH_TYPE_SHA256;
11156                    salt_type   = SALT_TYPE_EMBEDDED;
11157                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11158                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11159                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11160                    dgst_size   = DGST_SIZE_4_8;
11161                    parse_func  = veracrypt_parse_hash_200000;
11162                    sort_by_digest = sort_by_digest_4_8;
11163                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11164                    dgst_pos0   = 0;
11165                    dgst_pos1   = 1;
11166                    dgst_pos2   = 2;
11167                    dgst_pos3   = 3;
11168                    break;
11169
11170       case 13762:  hash_type   = HASH_TYPE_SHA256;
11171                    salt_type   = SALT_TYPE_EMBEDDED;
11172                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11173                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11174                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11175                    dgst_size   = DGST_SIZE_4_8;
11176                    parse_func  = veracrypt_parse_hash_200000;
11177                    sort_by_digest = sort_by_digest_4_8;
11178                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11179                    dgst_pos0   = 0;
11180                    dgst_pos1   = 1;
11181                    dgst_pos2   = 2;
11182                    dgst_pos3   = 3;
11183                    break;
11184
11185       case 13763:  hash_type   = HASH_TYPE_SHA256;
11186                    salt_type   = SALT_TYPE_EMBEDDED;
11187                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11188                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11189                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11190                    dgst_size   = DGST_SIZE_4_8;
11191                    parse_func  = veracrypt_parse_hash_200000;
11192                    sort_by_digest = sort_by_digest_4_8;
11193                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11194                    dgst_pos0   = 0;
11195                    dgst_pos1   = 1;
11196                    dgst_pos2   = 2;
11197                    dgst_pos3   = 3;
11198                    break;
11199
11200       case 13800:  hash_type   = HASH_TYPE_SHA256;
11201                    salt_type   = SALT_TYPE_EMBEDDED;
11202                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11203                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11204                                | OPTS_TYPE_PT_UNICODE;
11205                    kern_type   = KERN_TYPE_WIN8PHONE;
11206                    dgst_size   = DGST_SIZE_4_8;
11207                    parse_func  = win8phone_parse_hash;
11208                    sort_by_digest = sort_by_digest_4_8;
11209                    opti_type   = OPTI_TYPE_ZERO_BYTE
11210                                | OPTI_TYPE_PRECOMPUTE_INIT
11211                                | OPTI_TYPE_EARLY_SKIP
11212                                | OPTI_TYPE_NOT_ITERATED
11213                                | OPTI_TYPE_RAW_HASH;
11214                    dgst_pos0   = 3;
11215                    dgst_pos1   = 7;
11216                    dgst_pos2   = 2;
11217                    dgst_pos3   = 6;
11218                    break;
11219
11220       default:     usage_mini_print (PROGNAME); return (-1);
11221     }
11222
11223     /**
11224      * parser
11225      */
11226
11227     data.parse_func = parse_func;
11228
11229     /**
11230      * misc stuff
11231      */
11232
11233     if (hex_salt)
11234     {
11235       if (salt_type == SALT_TYPE_INTERN)
11236       {
11237         opts_type |= OPTS_TYPE_ST_HEX;
11238       }
11239       else
11240       {
11241         log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11242
11243         return (-1);
11244       }
11245     }
11246
11247     uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11248                   |  (salt_type == SALT_TYPE_EXTERN)
11249                   |  (salt_type == SALT_TYPE_EMBEDDED)
11250                   |  (salt_type == SALT_TYPE_VIRTUAL));
11251
11252     sort_by_digest = sort_by_digest_p0p1;  // overruled by 64 bit digest
11253
11254     data.hash_type   = hash_type;
11255     data.attack_mode = attack_mode;
11256     data.attack_kern = attack_kern;
11257     data.attack_exec = attack_exec;
11258     data.kern_type   = kern_type;
11259     data.opts_type   = opts_type;
11260     data.dgst_size   = dgst_size;
11261     data.salt_type   = salt_type;
11262     data.isSalted    = isSalted;
11263     data.sort_by_digest = sort_by_digest;
11264     data.dgst_pos0   = dgst_pos0;
11265     data.dgst_pos1   = dgst_pos1;
11266     data.dgst_pos2   = dgst_pos2;
11267     data.dgst_pos3   = dgst_pos3;
11268
11269     esalt_size = 0;
11270
11271     switch (hash_mode)
11272     {
11273       case  2500:  esalt_size = sizeof (wpa_t);           break;
11274       case  5300:  esalt_size = sizeof (ikepsk_t);        break;
11275       case  5400:  esalt_size = sizeof (ikepsk_t);        break;
11276       case  5500:  esalt_size = sizeof (netntlm_t);       break;
11277       case  5600:  esalt_size = sizeof (netntlm_t);       break;
11278       case  6211:  esalt_size = sizeof (tc_t);            break;
11279       case  6212:  esalt_size = sizeof (tc_t);            break;
11280       case  6213:  esalt_size = sizeof (tc_t);            break;
11281       case  6221:  esalt_size = sizeof (tc_t);            break;
11282       case  6222:  esalt_size = sizeof (tc_t);            break;
11283       case  6223:  esalt_size = sizeof (tc_t);            break;
11284       case  6231:  esalt_size = sizeof (tc_t);            break;
11285       case  6232:  esalt_size = sizeof (tc_t);            break;
11286       case  6233:  esalt_size = sizeof (tc_t);            break;
11287       case  6241:  esalt_size = sizeof (tc_t);            break;
11288       case  6242:  esalt_size = sizeof (tc_t);            break;
11289       case  6243:  esalt_size = sizeof (tc_t);            break;
11290       case  6600:  esalt_size = sizeof (agilekey_t);      break;
11291       case  7100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11292       case  7200:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11293       case  7300:  esalt_size = sizeof (rakp_t);          break;
11294       case  7500:  esalt_size = sizeof (krb5pa_t);        break;
11295       case  8200:  esalt_size = sizeof (cloudkey_t);      break;
11296       case  8800:  esalt_size = sizeof (androidfde_t);    break;
11297       case  9200:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11298       case  9400:  esalt_size = sizeof (office2007_t);    break;
11299       case  9500:  esalt_size = sizeof (office2010_t);    break;
11300       case  9600:  esalt_size = sizeof (office2013_t);    break;
11301       case  9700:  esalt_size = sizeof (oldoffice01_t);   break;
11302       case  9710:  esalt_size = sizeof (oldoffice01_t);   break;
11303       case  9720:  esalt_size = sizeof (oldoffice01_t);   break;
11304       case  9800:  esalt_size = sizeof (oldoffice34_t);   break;
11305       case  9810:  esalt_size = sizeof (oldoffice34_t);   break;
11306       case  9820:  esalt_size = sizeof (oldoffice34_t);   break;
11307       case 10000:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11308       case 10200:  esalt_size = sizeof (cram_md5_t);      break;
11309       case 10400:  esalt_size = sizeof (pdf_t);           break;
11310       case 10410:  esalt_size = sizeof (pdf_t);           break;
11311       case 10420:  esalt_size = sizeof (pdf_t);           break;
11312       case 10500:  esalt_size = sizeof (pdf_t);           break;
11313       case 10600:  esalt_size = sizeof (pdf_t);           break;
11314       case 10700:  esalt_size = sizeof (pdf_t);           break;
11315       case 10900:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11316       case 11300:  esalt_size = sizeof (bitcoin_wallet_t); break;
11317       case 11400:  esalt_size = sizeof (sip_t);           break;
11318       case 11600:  esalt_size = sizeof (seven_zip_t);     break;
11319       case 11900:  esalt_size = sizeof (pbkdf2_md5_t);    break;
11320       case 12000:  esalt_size = sizeof (pbkdf2_sha1_t);   break;
11321       case 12100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11322       case 13000:  esalt_size = sizeof (rar5_t);          break;
11323       case 13100:  esalt_size = sizeof (krb5tgs_t);       break;
11324       case 13400:  esalt_size = sizeof (keepass_t);       break;
11325       case 13500:  esalt_size = sizeof (pstoken_t);       break;
11326       case 13600:  esalt_size = sizeof (zip2_t);          break;
11327       case 13711:  esalt_size = sizeof (tc_t);            break;
11328       case 13712:  esalt_size = sizeof (tc_t);            break;
11329       case 13713:  esalt_size = sizeof (tc_t);            break;
11330       case 13721:  esalt_size = sizeof (tc_t);            break;
11331       case 13722:  esalt_size = sizeof (tc_t);            break;
11332       case 13723:  esalt_size = sizeof (tc_t);            break;
11333       case 13731:  esalt_size = sizeof (tc_t);            break;
11334       case 13732:  esalt_size = sizeof (tc_t);            break;
11335       case 13733:  esalt_size = sizeof (tc_t);            break;
11336       case 13741:  esalt_size = sizeof (tc_t);            break;
11337       case 13742:  esalt_size = sizeof (tc_t);            break;
11338       case 13743:  esalt_size = sizeof (tc_t);            break;
11339       case 13751:  esalt_size = sizeof (tc_t);            break;
11340       case 13752:  esalt_size = sizeof (tc_t);            break;
11341       case 13753:  esalt_size = sizeof (tc_t);            break;
11342       case 13761:  esalt_size = sizeof (tc_t);            break;
11343       case 13762:  esalt_size = sizeof (tc_t);            break;
11344       case 13763:  esalt_size = sizeof (tc_t);            break;
11345       case 13800:  esalt_size = sizeof (win8phone_t);     break;
11346     }
11347
11348     data.esalt_size = esalt_size;
11349
11350     /**
11351      * choose dictionary parser
11352      */
11353
11354     if (hash_type == HASH_TYPE_LM)
11355     {
11356       get_next_word_func = get_next_word_lm;
11357     }
11358     else if (opts_type & OPTS_TYPE_PT_UPPER)
11359     {
11360       get_next_word_func = get_next_word_uc;
11361     }
11362     else
11363     {
11364       get_next_word_func = get_next_word_std;
11365     }
11366
11367     /**
11368      * dictstat
11369      */
11370
11371     dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11372
11373     #ifdef _POSIX
11374     size_t dictstat_nmemb = 0;
11375     #endif
11376
11377     #ifdef _WIN
11378     uint   dictstat_nmemb = 0;
11379     #endif
11380
11381     char dictstat[256] = { 0 };
11382
11383     FILE *dictstat_fp = NULL;
11384
11385     if (keyspace == 0)
11386     {
11387       snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11388
11389       dictstat_fp = fopen (dictstat, "rb");
11390
11391       if (dictstat_fp)
11392       {
11393         #ifdef _POSIX
11394         struct stat tmpstat;
11395
11396         fstat (fileno (dictstat_fp), &tmpstat);
11397         #endif
11398
11399         #ifdef _WIN
11400         struct stat64 tmpstat;
11401
11402         _fstat64 (fileno (dictstat_fp), &tmpstat);
11403         #endif
11404
11405         if (tmpstat.st_mtime < COMPTIME)
11406         {
11407           /* with v0.15 the format changed so we have to ensure user is using a good version
11408              since there is no version-header in the dictstat file */
11409
11410           fclose (dictstat_fp);
11411
11412           unlink (dictstat);
11413         }
11414         else
11415         {
11416           while (!feof (dictstat_fp))
11417           {
11418             dictstat_t d;
11419
11420             if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11421
11422             lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11423
11424             if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11425             {
11426               log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11427
11428               return -1;
11429             }
11430           }
11431
11432           fclose (dictstat_fp);
11433         }
11434       }
11435     }
11436
11437     /**
11438      * potfile
11439      */
11440
11441     char potfile[256] = { 0 };
11442
11443     if (potfile_path == NULL)
11444     {
11445       snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11446     }
11447     else
11448     {
11449       strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11450     }
11451
11452     data.pot_fp = NULL;
11453
11454     FILE *out_fp = NULL;
11455     FILE *pot_fp = NULL;
11456
11457     if (show == 1 || left == 1)
11458     {
11459       pot_fp = fopen (potfile, "rb");
11460
11461       if (pot_fp == NULL)
11462       {
11463         log_error ("ERROR: %s: %s", potfile, strerror (errno));
11464
11465         return (-1);
11466       }
11467
11468       if (outfile != NULL)
11469       {
11470         if ((out_fp = fopen (outfile, "ab")) == NULL)
11471         {
11472           log_error ("ERROR: %s: %s", outfile, strerror (errno));
11473
11474           fclose (pot_fp);
11475
11476           return (-1);
11477         }
11478       }
11479       else
11480       {
11481         out_fp = stdout;
11482       }
11483     }
11484     else
11485     {
11486       if (potfile_disable == 0)
11487       {
11488         pot_fp = fopen (potfile, "ab");
11489
11490         if (pot_fp == NULL)
11491         {
11492           log_error ("ERROR: %s: %s", potfile, strerror (errno));
11493
11494           return (-1);
11495         }
11496
11497         data.pot_fp = pot_fp;
11498       }
11499     }
11500
11501     pot_t *pot = NULL;
11502
11503     uint pot_cnt   = 0;
11504     uint pot_avail = 0;
11505
11506     if (show == 1 || left == 1)
11507     {
11508       SUPPRESS_OUTPUT = 1;
11509
11510       pot_avail = count_lines (pot_fp);
11511
11512       rewind (pot_fp);
11513
11514       pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11515
11516       uint pot_hashes_avail = 0;
11517
11518       uint line_num = 0;
11519
11520       char *line_buf = (char *) mymalloc (HCBUFSIZ);
11521
11522       while (!feof (pot_fp))
11523       {
11524         line_num++;
11525
11526         int line_len = fgetl (pot_fp, line_buf);
11527
11528         if (line_len == 0) continue;
11529
11530         char *plain_buf = line_buf + line_len;
11531
11532         pot_t *pot_ptr = &pot[pot_cnt];
11533
11534         hash_t *hashes_buf = &pot_ptr->hash;
11535
11536         // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11537         // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11538
11539         if (pot_cnt == pot_hashes_avail)
11540         {
11541           uint pos = 0;
11542
11543           for (pos = 0; pos < INCR_POT; pos++)
11544           {
11545             if ((pot_cnt + pos) >= pot_avail) break;
11546
11547             pot_t *tmp_pot = &pot[pot_cnt + pos];
11548
11549             hash_t *tmp_hash = &tmp_pot->hash;
11550
11551             tmp_hash->digest = mymalloc (dgst_size);
11552
11553             if (isSalted)
11554             {
11555               tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11556             }
11557
11558             if (esalt_size)
11559             {
11560               tmp_hash->esalt = mymalloc (esalt_size);
11561             }
11562
11563             pot_hashes_avail++;
11564           }
11565         }
11566
11567         int plain_len = 0;
11568
11569         int parser_status;
11570
11571         int iter = MAX_CUT_TRIES;
11572
11573         do
11574         {
11575           for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11576           {
11577             if (line_buf[i] == ':')
11578             {
11579               line_len--;
11580
11581               break;
11582             }
11583           }
11584
11585           if (data.hash_mode != 2500)
11586           {
11587             parser_status = parse_func (line_buf, line_len, hashes_buf);
11588           }
11589           else
11590           {
11591             int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11592
11593             if (line_len > max_salt_size)
11594             {
11595               parser_status = PARSER_GLOBAL_LENGTH;
11596             }
11597             else
11598             {
11599               memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11600
11601               memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11602
11603               hashes_buf->salt->salt_len = line_len;
11604
11605               parser_status = PARSER_OK;
11606             }
11607           }
11608
11609           // if NOT parsed without error, we add the ":" to the plain
11610
11611           if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11612           {
11613             plain_len++;
11614             plain_buf--;
11615           }
11616
11617         } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11618
11619         if (parser_status < PARSER_GLOBAL_ZERO)
11620         {
11621           // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11622
11623           continue;
11624         }
11625
11626         if (plain_len >= 255) continue;
11627
11628         memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11629
11630         pot_ptr->plain_len = plain_len;
11631
11632         pot_cnt++;
11633       }
11634
11635       myfree (line_buf);
11636
11637       fclose (pot_fp);
11638
11639       SUPPRESS_OUTPUT = 0;
11640
11641       qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11642     }
11643
11644     /**
11645      * word len
11646      */
11647
11648     uint pw_min = PW_MIN;
11649     uint pw_max = PW_MAX;
11650
11651     switch (hash_mode)
11652     {
11653       case   125: if (pw_max > 32) pw_max = 32;
11654                   break;
11655       case   400: if (pw_max > 40) pw_max = 40;
11656                   break;
11657       case   500: if (pw_max > 16) pw_max = 16;
11658                   break;
11659       case  1500: if (pw_max >  8) pw_max =  8;
11660                   break;
11661       case  1600: if (pw_max > 16) pw_max = 16;
11662                   break;
11663       case  1800: if (pw_max > 16) pw_max = 16;
11664                   break;
11665       case  2100: if (pw_max > 16) pw_max = 16;
11666                   break;
11667       case  2500: if (pw_min <  8) pw_min =  8;
11668                   break;
11669       case  3000: if (pw_max >  7) pw_max =  7;
11670                   break;
11671       case  5200: if (pw_max > 24) pw_max = 24;
11672                   break;
11673       case  5800: if (pw_max > 16) pw_max = 16;
11674                   break;
11675       case  6300: if (pw_max > 16) pw_max = 16;
11676                   break;
11677       case  7400: if (pw_max > 16) pw_max = 16;
11678                   break;
11679       case  7700: if (pw_max >  8) pw_max =  8;
11680                   break;
11681       case  7900: if (pw_max > 48) pw_max = 48;
11682                   break;
11683       case  8500: if (pw_max >  8) pw_max =  8;
11684                   break;
11685       case  8600: if (pw_max > 16) pw_max = 16;
11686                   break;
11687       case  9710: pw_min = 5;
11688                   pw_max = 5;
11689                   break;
11690       case  9810: pw_min = 5;
11691                   pw_max = 5;
11692                   break;
11693       case 10410: pw_min = 5;
11694                   pw_max = 5;
11695                   break;
11696       case 10300: if (pw_max <  3) pw_min =  3;
11697                   if (pw_max > 40) pw_max = 40;
11698                   break;
11699       case 10500: if (pw_max <  3) pw_min =  3;
11700                   if (pw_max > 40) pw_max = 40;
11701                   break;
11702       case 10700: if (pw_max > 16) pw_max = 16;
11703                   break;
11704       case 11300: if (pw_max > 40) pw_max = 40;
11705                   break;
11706       case 11600: if (pw_max > 32) pw_max = 32;
11707                   break;
11708       case 12500: if (pw_max > 20) pw_max = 20;
11709                   break;
11710       case 12800: if (pw_max > 24) pw_max = 24;
11711                   break;
11712     }
11713
11714     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11715     {
11716       switch (attack_kern)
11717       {
11718         case ATTACK_KERN_STRAIGHT:  if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11719                                     break;
11720         case ATTACK_KERN_COMBI:     if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11721                                     break;
11722       }
11723     }
11724
11725     /**
11726      * charsets : keep them together for more easy maintainnce
11727      */
11728
11729     cs_t mp_sys[6] = { { { 0 }, 0 } };
11730     cs_t mp_usr[4] = { { { 0 }, 0 } };
11731
11732     mp_setup_sys (mp_sys);
11733
11734     if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11735     if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11736     if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11737     if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11738
11739     /**
11740      * load hashes, part I: find input mode, count hashes
11741      */
11742
11743     uint hashlist_mode   = 0;
11744     uint hashlist_format = HLFMT_HASHCAT;
11745
11746     uint hashes_avail = 0;
11747
11748     if ((benchmark == 0) && (stdout_flag == 0))
11749     {
11750       struct stat f;
11751
11752       hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11753
11754       if ((hash_mode == 2500) ||
11755           (hash_mode == 5200) ||
11756           ((hash_mode >=  6200) && (hash_mode <=  6299)) ||
11757           ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11758           (hash_mode == 9000))
11759       {
11760         hashlist_mode = HL_MODE_ARG;
11761
11762         char *hashfile = myargv[optind];
11763
11764         data.hashfile = hashfile;
11765
11766         logfile_top_var_string ("target", hashfile);
11767       }
11768
11769       if (hashlist_mode == HL_MODE_ARG)
11770       {
11771         if (hash_mode == 2500)
11772         {
11773           struct stat st;
11774
11775           if (stat (data.hashfile, &st) == -1)
11776           {
11777             log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11778
11779             return (-1);
11780           }
11781
11782           hashes_avail = st.st_size / sizeof (hccap_t);
11783         }
11784         else
11785         {
11786           hashes_avail = 1;
11787         }
11788       }
11789       else if (hashlist_mode == HL_MODE_FILE)
11790       {
11791         char *hashfile = myargv[optind];
11792
11793         data.hashfile = hashfile;
11794
11795         logfile_top_var_string ("target", hashfile);
11796
11797         FILE *fp = NULL;
11798
11799         if ((fp = fopen (hashfile, "rb")) == NULL)
11800         {
11801           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11802
11803           return (-1);
11804         }
11805
11806         if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11807
11808         hashes_avail = count_lines (fp);
11809
11810         rewind (fp);
11811
11812         if (hashes_avail == 0)
11813         {
11814           log_error ("ERROR: hashfile is empty or corrupt");
11815
11816           fclose (fp);
11817
11818           return (-1);
11819         }
11820
11821         hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11822
11823         if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11824         {
11825           log_error ("ERROR: remove not supported in native hashfile-format mode");
11826
11827           fclose (fp);
11828
11829           return (-1);
11830         }
11831
11832         fclose (fp);
11833       }
11834     }
11835     else
11836     {
11837       hashlist_mode = HL_MODE_ARG;
11838
11839       hashes_avail = 1;
11840     }
11841
11842     if (hash_mode == 3000) hashes_avail *= 2;
11843
11844     data.hashlist_mode   = hashlist_mode;
11845     data.hashlist_format = hashlist_format;
11846
11847     logfile_top_uint (hashlist_mode);
11848     logfile_top_uint (hashlist_format);
11849
11850     /**
11851      * load hashes, part II: allocate required memory, set pointers
11852      */
11853
11854     hash_t *hashes_buf  = NULL;
11855     void   *digests_buf = NULL;
11856     salt_t *salts_buf   = NULL;
11857     void   *esalts_buf  = NULL;
11858
11859     hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11860
11861     digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11862
11863     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11864     {
11865       u32 hash_pos;
11866
11867       for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11868       {
11869         hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11870
11871         hashes_buf[hash_pos].hash_info = hash_info;
11872
11873         if (username && (remove || show || left))
11874         {
11875           hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11876         }
11877
11878         if (benchmark)
11879         {
11880           hash_info->orighash = (char *) mymalloc (256);
11881         }
11882       }
11883     }
11884
11885     if (isSalted)
11886     {
11887       salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11888
11889       if (esalt_size)
11890       {
11891         esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11892       }
11893     }
11894     else
11895     {
11896       salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11897     }
11898
11899     for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11900     {
11901       hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11902
11903       if (isSalted)
11904       {
11905         hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11906
11907         if (esalt_size)
11908         {
11909           hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11910         }
11911       }
11912       else
11913       {
11914         hashes_buf[hash_pos].salt = &salts_buf[0];
11915       }
11916     }
11917
11918     /**
11919      * load hashes, part III: parse hashes or generate them if benchmark
11920      */
11921
11922     uint hashes_cnt = 0;
11923
11924     if (benchmark == 0)
11925     {
11926       if (keyspace == 1)
11927       {
11928         // useless to read hash file for keyspace, cheat a little bit w/ optind
11929       }
11930       else if (stdout_flag == 1)
11931       {
11932         // useless to read hash file for stdout, cheat a little bit w/ optind
11933       }
11934       else if (hashes_avail == 0)
11935       {
11936       }
11937       else if (hashlist_mode == HL_MODE_ARG)
11938       {
11939         char *input_buf = myargv[optind];
11940
11941         uint input_len = strlen (input_buf);
11942
11943         logfile_top_var_string ("target", input_buf);
11944
11945         char *hash_buf = NULL;
11946         int   hash_len = 0;
11947
11948         hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11949
11950         bool hash_fmt_error = 0;
11951
11952         if (hash_len < 1)     hash_fmt_error = 1;
11953         if (hash_buf == NULL) hash_fmt_error = 1;
11954
11955         if (hash_fmt_error)
11956         {
11957           log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11958         }
11959         else
11960         {
11961           if (opts_type & OPTS_TYPE_HASH_COPY)
11962           {
11963             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11964
11965             hash_info_tmp->orighash = mystrdup (hash_buf);
11966           }
11967
11968           if (isSalted)
11969           {
11970             memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11971           }
11972
11973           int parser_status = PARSER_OK;
11974
11975           if (hash_mode == 2500)
11976           {
11977             if (hash_len == 0)
11978             {
11979               log_error ("ERROR: hccap file not specified");
11980
11981               return (-1);
11982             }
11983
11984             hashlist_mode = HL_MODE_FILE;
11985
11986             data.hashlist_mode = hashlist_mode;
11987
11988             FILE *fp = fopen (hash_buf, "rb");
11989
11990             if (fp == NULL)
11991             {
11992               log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11993
11994               return (-1);
11995             }
11996
11997             if (hashes_avail < 1)
11998             {
11999               log_error ("ERROR: hccap file is empty or corrupt");
12000
12001               fclose (fp);
12002
12003               return (-1);
12004             }
12005
12006             uint hccap_size = sizeof (hccap_t);
12007
12008             char *in = (char *) mymalloc (hccap_size);
12009
12010             while (!feof (fp))
12011             {
12012               int n = fread (in, hccap_size, 1, fp);
12013
12014               if (n != 1)
12015               {
12016                 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12017
12018                 break;
12019               }
12020
12021               parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12022
12023               if (parser_status != PARSER_OK)
12024               {
12025                 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12026
12027                 continue;
12028               }
12029
12030               // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12031
12032               if ((show == 1) || (left == 1))
12033               {
12034                 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12035
12036                 char *salt_ptr = (char *) tmp_salt->salt_buf;
12037
12038                 int cur_pos = tmp_salt->salt_len;
12039                 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12040
12041                 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12042
12043                 // do the appending task
12044
12045                 snprintf (salt_ptr + cur_pos,
12046                           rem_len,
12047                           ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12048                           wpa->orig_mac1[0],
12049                           wpa->orig_mac1[1],
12050                           wpa->orig_mac1[2],
12051                           wpa->orig_mac1[3],
12052                           wpa->orig_mac1[4],
12053                           wpa->orig_mac1[5],
12054                           wpa->orig_mac2[0],
12055                           wpa->orig_mac2[1],
12056                           wpa->orig_mac2[2],
12057                           wpa->orig_mac2[3],
12058                           wpa->orig_mac2[4],
12059                           wpa->orig_mac2[5]);
12060
12061                 // memset () the remaining part of the salt
12062
12063                 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12064                 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12065
12066                 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12067
12068                 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12069               }
12070
12071               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);
12072               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);
12073
12074               hashes_cnt++;
12075             }
12076
12077             fclose (fp);
12078
12079             myfree (in);
12080           }
12081           else if (hash_mode == 3000)
12082           {
12083             if (hash_len == 32)
12084             {
12085               parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12086
12087               hash_t *lm_hash_left = NULL;
12088
12089               if (parser_status == PARSER_OK)
12090               {
12091                 lm_hash_left = &hashes_buf[hashes_cnt];
12092
12093                 hashes_cnt++;
12094               }
12095               else
12096               {
12097                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12098               }
12099
12100               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12101
12102               hash_t *lm_hash_right = NULL;
12103
12104               if (parser_status == PARSER_OK)
12105               {
12106                 lm_hash_right = &hashes_buf[hashes_cnt];
12107
12108                 hashes_cnt++;
12109               }
12110               else
12111               {
12112                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12113               }
12114
12115               // show / left
12116
12117               if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12118               {
12119                 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);
12120                 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);
12121               }
12122             }
12123             else
12124             {
12125               parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12126
12127               if (parser_status == PARSER_OK)
12128               {
12129                 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12130                 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12131               }
12132
12133               if (parser_status == PARSER_OK)
12134               {
12135                 hashes_cnt++;
12136               }
12137               else
12138               {
12139                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12140               }
12141             }
12142           }
12143           else
12144           {
12145             parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12146
12147             if (parser_status == PARSER_OK)
12148             {
12149               if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12150               if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12151             }
12152
12153             if (parser_status == PARSER_OK)
12154             {
12155               hashes_cnt++;
12156             }
12157             else
12158             {
12159               log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12160             }
12161           }
12162         }
12163       }
12164       else if (hashlist_mode == HL_MODE_FILE)
12165       {
12166         char *hashfile = data.hashfile;
12167
12168         FILE *fp;
12169
12170         if ((fp = fopen (hashfile, "rb")) == NULL)
12171         {
12172           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12173
12174           return (-1);
12175         }
12176
12177         uint line_num = 0;
12178
12179         char *line_buf = (char *) mymalloc (HCBUFSIZ);
12180
12181         while (!feof (fp))
12182         {
12183           line_num++;
12184
12185           int line_len = fgetl (fp, line_buf);
12186
12187           if (line_len == 0) continue;
12188
12189           char *hash_buf = NULL;
12190           int   hash_len = 0;
12191
12192           hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12193
12194           bool hash_fmt_error = 0;
12195
12196           if (hash_len < 1)     hash_fmt_error = 1;
12197           if (hash_buf == NULL) hash_fmt_error = 1;
12198
12199           if (hash_fmt_error)
12200           {
12201             log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12202
12203             continue;
12204           }
12205
12206           if (username)
12207           {
12208             char *user_buf = NULL;
12209             int   user_len = 0;
12210
12211             hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12212
12213             if (remove || show)
12214             {
12215               user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12216
12217               *user = (user_t *) mymalloc (sizeof (user_t));
12218
12219               user_t *user_ptr = *user;
12220
12221               if (user_buf != NULL)
12222               {
12223                 user_ptr->user_name = mystrdup (user_buf);
12224               }
12225               else
12226               {
12227                 user_ptr->user_name = mystrdup ("");
12228               }
12229
12230               user_ptr->user_len = user_len;
12231             }
12232           }
12233
12234           if (opts_type & OPTS_TYPE_HASH_COPY)
12235           {
12236             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12237
12238             hash_info_tmp->orighash = mystrdup (hash_buf);
12239           }
12240
12241           if (isSalted)
12242           {
12243             memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12244           }
12245
12246           if (hash_mode == 3000)
12247           {
12248             if (hash_len == 32)
12249             {
12250               int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12251
12252               if (parser_status < PARSER_GLOBAL_ZERO)
12253               {
12254                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12255
12256                 continue;
12257               }
12258
12259               hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12260
12261               hashes_cnt++;
12262
12263               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12264
12265               if (parser_status < PARSER_GLOBAL_ZERO)
12266               {
12267                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12268
12269                 continue;
12270               }
12271
12272               hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12273
12274               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);
12275
12276               hashes_cnt++;
12277
12278               // show / left
12279
12280               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);
12281               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);
12282             }
12283             else
12284             {
12285               int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12286
12287               if (parser_status < PARSER_GLOBAL_ZERO)
12288               {
12289                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12290
12291                 continue;
12292               }
12293
12294               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);
12295
12296               if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12297               if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12298
12299               hashes_cnt++;
12300             }
12301           }
12302           else
12303           {
12304             int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12305
12306             if (parser_status < PARSER_GLOBAL_ZERO)
12307             {
12308               log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12309
12310               continue;
12311             }
12312
12313             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);
12314
12315             if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12316             if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12317
12318             hashes_cnt++;
12319           }
12320         }
12321
12322         myfree (line_buf);
12323
12324         fclose (fp);
12325
12326         if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12327
12328         if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12329       }
12330     }
12331     else
12332     {
12333       if (isSalted)
12334       {
12335         hashes_buf[0].salt->salt_len = 8;
12336
12337         // special salt handling
12338
12339         switch (hash_mode)
12340         {
12341           case  1500: hashes_buf[0].salt->salt_len    = 2;
12342                       hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12343                       break;
12344           case  1731: hashes_buf[0].salt->salt_len = 4;
12345                       break;
12346           case  2410: hashes_buf[0].salt->salt_len = 4;
12347                       break;
12348           case  2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12349                       break;
12350           case  3100: hashes_buf[0].salt->salt_len = 1;
12351                       break;
12352           case  5000: hashes_buf[0].salt->keccak_mdlen = 32;
12353                       break;
12354           case  5800: hashes_buf[0].salt->salt_len = 16;
12355                       break;
12356           case  6800: hashes_buf[0].salt->salt_len = 32;
12357                       break;
12358           case  8400: hashes_buf[0].salt->salt_len = 40;
12359                       break;
12360           case  8800: hashes_buf[0].salt->salt_len = 16;
12361                       break;
12362           case  8900: hashes_buf[0].salt->salt_len = 16;
12363                       hashes_buf[0].salt->scrypt_N = 1024;
12364                       hashes_buf[0].salt->scrypt_r = 1;
12365                       hashes_buf[0].salt->scrypt_p = 1;
12366                       break;
12367           case  9100: hashes_buf[0].salt->salt_len = 16;
12368                       break;
12369           case  9300: hashes_buf[0].salt->salt_len = 14;
12370                       hashes_buf[0].salt->scrypt_N = 16384;
12371                       hashes_buf[0].salt->scrypt_r = 1;
12372                       hashes_buf[0].salt->scrypt_p = 1;
12373                       break;
12374           case  9400: hashes_buf[0].salt->salt_len = 16;
12375                       break;
12376           case  9500: hashes_buf[0].salt->salt_len = 16;
12377                       break;
12378           case  9600: hashes_buf[0].salt->salt_len = 16;
12379                       break;
12380           case  9700: hashes_buf[0].salt->salt_len = 16;
12381                       break;
12382           case  9710: hashes_buf[0].salt->salt_len = 16;
12383                       break;
12384           case  9720: hashes_buf[0].salt->salt_len = 16;
12385                       break;
12386           case  9800: hashes_buf[0].salt->salt_len = 16;
12387                       break;
12388           case  9810: hashes_buf[0].salt->salt_len = 16;
12389                       break;
12390           case  9820: hashes_buf[0].salt->salt_len = 16;
12391                       break;
12392           case 10300: hashes_buf[0].salt->salt_len = 12;
12393                       break;
12394           case 11500: hashes_buf[0].salt->salt_len = 4;
12395                       break;
12396           case 11600: hashes_buf[0].salt->salt_len = 4;
12397                       break;
12398           case 12400: hashes_buf[0].salt->salt_len = 4;
12399                       break;
12400           case 12500: hashes_buf[0].salt->salt_len = 8;
12401                       break;
12402           case 12600: hashes_buf[0].salt->salt_len = 64;
12403                       break;
12404         }
12405
12406         // special esalt handling
12407
12408         switch (hash_mode)
12409         {
12410           case  2500: ((wpa_t *)     hashes_buf[0].esalt)->eapol_size   = 128;
12411                       break;
12412           case  5300: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12413                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12414                       break;
12415           case  5400: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12416                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12417                       break;
12418           case  5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12419                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12420                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12421                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12422                       break;
12423           case  5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12424                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12425                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12426                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12427                       break;
12428           case  7300: ((rakp_t *)    hashes_buf[0].esalt)->salt_len     = 32;
12429                       break;
12430           case 10400: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12431                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12432                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12433                       break;
12434           case 10410: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12435                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12436                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12437                       break;
12438           case 10420: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12439                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12440                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12441                       break;
12442           case 10500: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12443                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12444                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12445                       break;
12446           case 10600: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12447                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12448                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12449                       break;
12450           case 10700: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12451                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12452                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12453                       break;
12454           case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len      = 16;
12455                       ((seven_zip_t *) hashes_buf[0].esalt)->data_len    = 112;
12456                       ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12457                       break;
12458           case 13400: ((keepass_t *) hashes_buf[0].esalt)->version      = 2;
12459                       break;
12460           case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len     = 113;
12461                       break;
12462           case 13600: ((zip2_t *)    hashes_buf[0].esalt)->salt_len     = 16;
12463                       ((zip2_t *)    hashes_buf[0].esalt)->data_len     = 32;
12464                       ((zip2_t *)    hashes_buf[0].esalt)->mode         = 3;
12465                       break;
12466         }
12467       }
12468
12469       // set hashfile
12470
12471       switch (hash_mode)
12472       {
12473         case 5200:  data.hashfile = mystrdup ("hashcat.psafe3");
12474                     break;
12475         case 5300:  data.hashfile = mystrdup ("hashcat.ikemd5");
12476                     break;
12477         case 5400:  data.hashfile = mystrdup ("hashcat.ikesha1");
12478                     break;
12479         case 6211:  data.hashfile = mystrdup ("hashcat.tc");
12480                     break;
12481         case 6212:  data.hashfile = mystrdup ("hashcat.tc");
12482                     break;
12483         case 6213:  data.hashfile = mystrdup ("hashcat.tc");
12484                     break;
12485         case 6221:  data.hashfile = mystrdup ("hashcat.tc");
12486                     break;
12487         case 6222:  data.hashfile = mystrdup ("hashcat.tc");
12488                     break;
12489         case 6223:  data.hashfile = mystrdup ("hashcat.tc");
12490                     break;
12491         case 6231:  data.hashfile = mystrdup ("hashcat.tc");
12492                     break;
12493         case 6232:  data.hashfile = mystrdup ("hashcat.tc");
12494                     break;
12495         case 6233:  data.hashfile = mystrdup ("hashcat.tc");
12496                     break;
12497         case 6241:  data.hashfile = mystrdup ("hashcat.tc");
12498                     break;
12499         case 6242:  data.hashfile = mystrdup ("hashcat.tc");
12500                     break;
12501         case 6243:  data.hashfile = mystrdup ("hashcat.tc");
12502                     break;
12503         case 6600:  data.hashfile = mystrdup ("hashcat.agilekey");
12504                     break;
12505         case 8200:  data.hashfile = mystrdup ("hashcat.cloudkey");
12506                     break;
12507         case 9000:  data.hashfile = mystrdup ("hashcat.psafe2");
12508                     break;
12509         case 13711: data.hashfile = mystrdup ("hashcat.vc");
12510                     break;
12511         case 13712: data.hashfile = mystrdup ("hashcat.vc");
12512                     break;
12513         case 13713: data.hashfile = mystrdup ("hashcat.vc");
12514                     break;
12515         case 13721: data.hashfile = mystrdup ("hashcat.vc");
12516                     break;
12517         case 13722: data.hashfile = mystrdup ("hashcat.vc");
12518                     break;
12519         case 13723: data.hashfile = mystrdup ("hashcat.vc");
12520                     break;
12521         case 13731: data.hashfile = mystrdup ("hashcat.vc");
12522                     break;
12523         case 13732: data.hashfile = mystrdup ("hashcat.vc");
12524                     break;
12525         case 13733: data.hashfile = mystrdup ("hashcat.vc");
12526                     break;
12527         case 13741: data.hashfile = mystrdup ("hashcat.vc");
12528                     break;
12529         case 13742: data.hashfile = mystrdup ("hashcat.vc");
12530                     break;
12531         case 13743: data.hashfile = mystrdup ("hashcat.vc");
12532                     break;
12533         case 13751: data.hashfile = mystrdup ("hashcat.vc");
12534                     break;
12535         case 13752: data.hashfile = mystrdup ("hashcat.vc");
12536                     break;
12537         case 13753: data.hashfile = mystrdup ("hashcat.vc");
12538                     break;
12539         case 13761: data.hashfile = mystrdup ("hashcat.vc");
12540                     break;
12541         case 13762: data.hashfile = mystrdup ("hashcat.vc");
12542                     break;
12543         case 13763: data.hashfile = mystrdup ("hashcat.vc");
12544                     break;
12545       }
12546
12547       // set default iterations
12548
12549       switch (hash_mode)
12550       {
12551         case   400:  hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12552                      break;
12553         case   500:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12554                      break;
12555         case   501:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12556                      break;
12557         case  1600:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12558                      break;
12559         case  1800:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12560                      break;
12561         case  2100:  hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12562                      break;
12563         case  2500:  hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12564                      break;
12565         case  3200:  hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12566                      break;
12567         case  5200:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12568                      break;
12569         case  5800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12570                      break;
12571         case  6211:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12572                      break;
12573         case  6212:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12574                      break;
12575         case  6213:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12576                      break;
12577         case  6221:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12578                      break;
12579         case  6222:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12580                      break;
12581         case  6223:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12582                      break;
12583         case  6231:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12584                      break;
12585         case  6232:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586                      break;
12587         case  6233:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588                      break;
12589         case  6241:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12590                      break;
12591         case  6242:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12592                      break;
12593         case  6243:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12594                      break;
12595         case  6300:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12596                      break;
12597         case  6400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12598                      break;
12599         case  6500:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12600                      break;
12601         case  6700:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12602                      break;
12603         case  6600:  hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12604                      break;
12605         case  6800:  hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12606                      break;
12607         case  7100:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12608                      break;
12609         case  7200:  hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12610                      break;
12611         case  7400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12612                      break;
12613         case  7900:  hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12614                      break;
12615         case  8200:  hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12616                      break;
12617         case  8300:  hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12618                      break;
12619         case  8800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12620                      break;
12621         case  8900:  hashes_buf[0].salt->salt_iter = 1;
12622                      break;
12623         case  9000:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12624                      break;
12625         case  9100:  hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12626                      break;
12627         case  9200:  hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12628                      break;
12629         case  9300:  hashes_buf[0].salt->salt_iter = 1;
12630                      break;
12631         case  9400:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12632                      break;
12633         case  9500:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12634                      break;
12635         case  9600:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12636                      break;
12637         case 10000:  hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12638                      break;
12639         case 10300:  hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12640                      break;
12641         case 10500:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12642                      break;
12643         case 10700:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12644                      break;
12645         case 10900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12646                      break;
12647         case 11300:  hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12648                      break;
12649         case 11600:  hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12650                      break;
12651         case 11900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12652                      break;
12653         case 12000:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12654                      break;
12655         case 12100:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12656                      break;
12657         case 12200:  hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12658                      break;
12659         case 12300:  hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12660                      break;
12661         case 12400:  hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12662                      break;
12663         case 12500:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12664                      break;
12665         case 12700:  hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12666                      break;
12667         case 12800:  hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12668                      break;
12669         case 12900:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12670                      break;
12671         case 13000:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12672                      break;
12673         case 13200:  hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12674                      break;
12675         case 13400:  hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12676                      break;
12677         case 13600:  hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12678                      break;
12679         case 13711:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12680                      break;
12681         case 13712:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12682                      break;
12683         case 13713:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12684                      break;
12685         case 13721:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12686                      break;
12687         case 13722:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12688                      break;
12689         case 13723:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12690                      break;
12691         case 13731:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12692                      break;
12693         case 13732:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12694                      break;
12695         case 13733:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12696                      break;
12697         case 13741:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12698                      break;
12699         case 13742:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12700                      break;
12701         case 13743:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12702                      break;
12703         case 13751:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12704                      break;
12705         case 13752:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12706                      break;
12707         case 13753:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12708                      break;
12709         case 13761:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12710                      break;
12711         case 13762:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12712                      break;
12713         case 13763:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12714                      break;
12715       }
12716
12717       hashes_cnt = 1;
12718     }
12719
12720     if (show == 1 || left == 1)
12721     {
12722       for (uint i = 0; i < pot_cnt; i++)
12723       {
12724         pot_t *pot_ptr = &pot[i];
12725
12726         hash_t *hashes_buf = &pot_ptr->hash;
12727
12728         local_free (hashes_buf->digest);
12729
12730         if (isSalted)
12731         {
12732           local_free (hashes_buf->salt);
12733         }
12734       }
12735
12736       local_free (pot);
12737
12738       if (data.quiet == 0) log_info_nn ("");
12739
12740       return (0);
12741     }
12742
12743     if ((keyspace == 0) && (stdout_flag == 0))
12744     {
12745       if (hashes_cnt == 0)
12746       {
12747         log_error ("ERROR: No hashes loaded");
12748
12749         return (-1);
12750       }
12751     }
12752
12753     /**
12754      * Sanity check for hashfile vs outfile (should not point to the same physical file)
12755      */
12756
12757     if (data.outfile != NULL)
12758     {
12759       if (data.hashfile != NULL)
12760       {
12761         #ifdef _POSIX
12762         struct stat tmpstat_outfile;
12763         struct stat tmpstat_hashfile;
12764         #endif
12765
12766         #ifdef _WIN
12767         struct stat64 tmpstat_outfile;
12768         struct stat64 tmpstat_hashfile;
12769         #endif
12770
12771         FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12772
12773         if (tmp_outfile_fp)
12774         {
12775           #ifdef _POSIX
12776           fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12777           #endif
12778
12779           #ifdef _WIN
12780           _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12781           #endif
12782
12783           fclose (tmp_outfile_fp);
12784         }
12785
12786         FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12787
12788         if (tmp_hashfile_fp)
12789         {
12790           #ifdef _POSIX
12791           fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12792           #endif
12793
12794           #ifdef _WIN
12795           _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12796           #endif
12797
12798           fclose (tmp_hashfile_fp);
12799         }
12800
12801         if (tmp_outfile_fp && tmp_outfile_fp)
12802         {
12803           tmpstat_outfile.st_mode     = 0;
12804           tmpstat_outfile.st_nlink    = 0;
12805           tmpstat_outfile.st_uid      = 0;
12806           tmpstat_outfile.st_gid      = 0;
12807           tmpstat_outfile.st_rdev     = 0;
12808           tmpstat_outfile.st_atime    = 0;
12809
12810           tmpstat_hashfile.st_mode    = 0;
12811           tmpstat_hashfile.st_nlink   = 0;
12812           tmpstat_hashfile.st_uid     = 0;
12813           tmpstat_hashfile.st_gid     = 0;
12814           tmpstat_hashfile.st_rdev    = 0;
12815           tmpstat_hashfile.st_atime   = 0;
12816
12817           #ifdef _POSIX
12818           tmpstat_outfile.st_blksize  = 0;
12819           tmpstat_outfile.st_blocks   = 0;
12820
12821           tmpstat_hashfile.st_blksize = 0;
12822           tmpstat_hashfile.st_blocks  = 0;
12823           #endif
12824
12825           #ifdef _POSIX
12826           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12827           {
12828             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12829
12830             return (-1);
12831           }
12832           #endif
12833
12834           #ifdef _WIN
12835           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12836           {
12837             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12838
12839             return (-1);
12840           }
12841           #endif
12842         }
12843       }
12844     }
12845
12846     /**
12847      * Remove duplicates
12848      */
12849
12850     if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12851
12852     if (isSalted)
12853     {
12854       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12855     }
12856     else
12857     {
12858       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12859     }
12860
12861     uint hashes_cnt_orig = hashes_cnt;
12862
12863     hashes_cnt = 1;
12864
12865     for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12866     {
12867       if (isSalted)
12868       {
12869         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12870         {
12871           if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12872         }
12873       }
12874       else
12875       {
12876         if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12877       }
12878
12879       if (hashes_pos > hashes_cnt)
12880       {
12881         memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12882       }
12883
12884       hashes_cnt++;
12885     }
12886
12887     /**
12888      * Potfile removes
12889      */
12890
12891     uint potfile_remove_cracks = 0;
12892
12893     if (potfile_disable == 0)
12894     {
12895       hash_t hash_buf;
12896
12897       hash_buf.digest    = mymalloc (dgst_size);
12898       hash_buf.salt      = NULL;
12899       hash_buf.esalt     = NULL;
12900       hash_buf.hash_info = NULL;
12901       hash_buf.cracked   = 0;
12902
12903       if (isSalted)
12904       {
12905         hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12906       }
12907
12908       if (esalt_size)
12909       {
12910         hash_buf.esalt = mymalloc (esalt_size);
12911       }
12912
12913       if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12914
12915       // no solution for these special hash types (for instane because they use hashfile in output etc)
12916       if ((hash_mode != 5200) &&
12917           !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
12918           !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12919           (hash_mode != 9000))
12920       {
12921         FILE *fp = fopen (potfile, "rb");
12922
12923         if (fp != NULL)
12924         {
12925           char *line_buf = (char *) mymalloc (HCBUFSIZ);
12926
12927           // to be safe work with a copy (because of line_len loop, i etc)
12928           // moved up here because it's easier to handle continue case
12929           // it's just 64kb
12930
12931           char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12932
12933           while (!feof (fp))
12934           {
12935             char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12936
12937             if (ptr == NULL) break;
12938
12939             int line_len = strlen (line_buf);
12940
12941             if (line_len == 0) continue;
12942
12943             int iter = MAX_CUT_TRIES;
12944
12945             for (int i = line_len - 1; i && iter; i--, line_len--)
12946             {
12947               if (line_buf[i] != ':') continue;
12948
12949               if (isSalted)
12950               {
12951                 memset (hash_buf.salt, 0, sizeof (salt_t));
12952               }
12953
12954               hash_t *found = NULL;
12955
12956               if (hash_mode == 6800)
12957               {
12958                 if (i < 64) // 64 = 16 * uint in salt_buf[]
12959                 {
12960                   // manipulate salt_buf
12961                   memcpy (hash_buf.salt->salt_buf, line_buf, i);
12962
12963                   hash_buf.salt->salt_len = i;
12964
12965                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12966                 }
12967               }
12968               else if (hash_mode == 2500)
12969               {
12970                 if (i < 64) // 64 = 16 * uint in salt_buf[]
12971                 {
12972                   // here we have in line_buf: ESSID:MAC1:MAC2   (without the plain)
12973                   // manipulate salt_buf
12974
12975                   memcpy (line_buf_cpy, line_buf, i);
12976
12977                   char *mac2_pos = strrchr (line_buf_cpy, ':');
12978
12979                   if (mac2_pos == NULL) continue;
12980
12981                   mac2_pos[0] = 0;
12982                   mac2_pos++;
12983
12984                   if (strlen (mac2_pos) != 12) continue;
12985
12986                   char *mac1_pos = strrchr (line_buf_cpy, ':');
12987
12988                   if (mac1_pos == NULL) continue;
12989
12990                   mac1_pos[0] = 0;
12991                   mac1_pos++;
12992
12993                   if (strlen (mac1_pos) != 12) continue;
12994
12995                   uint essid_length = mac1_pos - line_buf_cpy - 1;
12996
12997                   // here we need the ESSID
12998                   memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12999
13000                   hash_buf.salt->salt_len = essid_length;
13001
13002                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13003
13004                   if (found)
13005                   {
13006                     wpa_t *wpa = (wpa_t *) found->esalt;
13007
13008                     // compare hex string(s) vs binary MAC address(es)
13009
13010                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13011                     {
13012                       if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13013                       {
13014                         found = NULL;
13015
13016                         break;
13017                       }
13018                     }
13019
13020                     // early skip ;)
13021                     if (!found) continue;
13022
13023                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13024                     {
13025                       if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13026                       {
13027                         found = NULL;
13028
13029                         break;
13030                       }
13031                     }
13032                   }
13033                 }
13034               }
13035               else
13036               {
13037                 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13038
13039                 if (parser_status == PARSER_OK)
13040                 {
13041                   if (isSalted)
13042                   {
13043                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13044                   }
13045                   else
13046                   {
13047                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13048                   }
13049                 }
13050               }
13051
13052               if (found == NULL) continue;
13053
13054               if (!found->cracked) potfile_remove_cracks++;
13055
13056               found->cracked = 1;
13057
13058               if (found) break;
13059
13060               iter--;
13061             }
13062           }
13063
13064           myfree (line_buf_cpy);
13065
13066           myfree (line_buf);
13067
13068           fclose (fp);
13069         }
13070       }
13071
13072       if (esalt_size)
13073       {
13074         local_free (hash_buf.esalt);
13075       }
13076
13077       if (isSalted)
13078       {
13079         local_free (hash_buf.salt);
13080       }
13081
13082       local_free (hash_buf.digest);
13083     }
13084
13085     /**
13086      * Now generate all the buffers required for later
13087      */
13088
13089     void   *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13090
13091     salt_t *salts_buf_new  = NULL;
13092     void   *esalts_buf_new = NULL;
13093
13094     if (isSalted)
13095     {
13096       salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13097
13098       if (esalt_size)
13099       {
13100         esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13101       }
13102     }
13103     else
13104     {
13105       salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13106     }
13107
13108     if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13109
13110     uint digests_cnt  = hashes_cnt;
13111     uint digests_done = 0;
13112
13113     size_t size_digests = digests_cnt * dgst_size;
13114     size_t size_shown   = digests_cnt * sizeof (uint);
13115
13116     uint *digests_shown     = (uint *) mymalloc (size_shown);
13117     uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13118
13119     uint salts_cnt   = 0;
13120     uint salts_done  = 0;
13121
13122     hashinfo_t **hash_info = NULL;
13123
13124     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13125     {
13126       hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13127
13128       if (username && (remove || show))
13129       {
13130         uint user_pos;
13131
13132         for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13133         {
13134           hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13135
13136           hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13137         }
13138       }
13139     }
13140
13141     uint *salts_shown = (uint *) mymalloc (size_shown);
13142
13143     salt_t *salt_buf;
13144
13145     {
13146       // copied from inner loop
13147
13148       salt_buf = &salts_buf_new[salts_cnt];
13149
13150       memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13151
13152       if (esalt_size)
13153       {
13154         memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13155       }
13156
13157       salt_buf->digests_cnt    = 0;
13158       salt_buf->digests_done   = 0;
13159       salt_buf->digests_offset = 0;
13160
13161       salts_cnt++;
13162     }
13163
13164     if (hashes_buf[0].cracked == 1)
13165     {
13166       digests_shown[0] = 1;
13167
13168       digests_done++;
13169
13170       salt_buf->digests_done++;
13171     }
13172
13173     salt_buf->digests_cnt++;
13174
13175     memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13176
13177     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13178     {
13179       hash_info[0] = hashes_buf[0].hash_info;
13180     }
13181
13182     // copy from inner loop
13183
13184     for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13185     {
13186       if (isSalted)
13187       {
13188         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13189         {
13190           salt_buf = &salts_buf_new[salts_cnt];
13191
13192           memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13193
13194           if (esalt_size)
13195           {
13196             memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13197           }
13198
13199           salt_buf->digests_cnt    = 0;
13200           salt_buf->digests_done   = 0;
13201           salt_buf->digests_offset = hashes_pos;
13202
13203           salts_cnt++;
13204         }
13205       }
13206
13207       if (hashes_buf[hashes_pos].cracked == 1)
13208       {
13209         digests_shown[hashes_pos] = 1;
13210
13211         digests_done++;
13212
13213         salt_buf->digests_done++;
13214       }
13215
13216       salt_buf->digests_cnt++;
13217
13218       memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13219
13220       if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13221       {
13222         hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13223       }
13224     }
13225
13226     for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13227     {
13228       salt_t *salt_buf = &salts_buf_new[salt_pos];
13229
13230       if (salt_buf->digests_done == salt_buf->digests_cnt)
13231       {
13232         salts_shown[salt_pos] = 1;
13233
13234         salts_done++;
13235       }
13236
13237       if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13238     }
13239
13240     local_free (digests_buf);
13241     local_free (salts_buf);
13242     local_free (esalts_buf);
13243
13244     digests_buf = digests_buf_new;
13245     salts_buf   = salts_buf_new;
13246     esalts_buf  = esalts_buf_new;
13247
13248     local_free (hashes_buf);
13249
13250     /**
13251      * special modification not set from parser
13252      */
13253
13254     switch (hash_mode)
13255     {
13256       case  6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13257       case  6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13258       case  6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13259       case  6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13260       case  6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13261       case  6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13262       case  6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13263       case  6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13264       case  6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13265       case  6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13266       case  6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13267       case  6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13268       case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13269       case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13270       case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13271       case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13272       case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13273       case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13274       case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13275       case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13276       case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13277       case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13278       case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13279       case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13280       case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13281       case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13282       case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13283       case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13284       case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13285       case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13286     }
13287
13288     if (truecrypt_keyfiles)
13289     {
13290       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13291
13292       char *keyfiles = strdup (truecrypt_keyfiles);
13293
13294       char *keyfile = strtok (keyfiles, ",");
13295
13296       do
13297       {
13298         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13299
13300       } while ((keyfile = strtok (NULL, ",")) != NULL);
13301
13302       free (keyfiles);
13303     }
13304
13305     if (veracrypt_keyfiles)
13306     {
13307       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13308
13309       char *keyfiles = strdup (veracrypt_keyfiles);
13310
13311       char *keyfile = strtok (keyfiles, ",");
13312
13313       do
13314       {
13315         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13316
13317       } while ((keyfile = strtok (NULL, ",")) != NULL);
13318
13319       free (keyfiles);
13320     }
13321
13322     data.digests_cnt        = digests_cnt;
13323     data.digests_done       = digests_done;
13324     data.digests_buf        = digests_buf;
13325     data.digests_shown      = digests_shown;
13326     data.digests_shown_tmp  = digests_shown_tmp;
13327
13328     data.salts_cnt          = salts_cnt;
13329     data.salts_done         = salts_done;
13330     data.salts_buf          = salts_buf;
13331     data.salts_shown        = salts_shown;
13332
13333     data.esalts_buf         = esalts_buf;
13334     data.hash_info          = hash_info;
13335
13336     /**
13337      * Automatic Optimizers
13338      */
13339
13340     if (salts_cnt == 1)
13341       opti_type |= OPTI_TYPE_SINGLE_SALT;
13342
13343     if (digests_cnt == 1)
13344       opti_type |= OPTI_TYPE_SINGLE_HASH;
13345
13346     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13347       opti_type |= OPTI_TYPE_NOT_ITERATED;
13348
13349     if (attack_mode == ATTACK_MODE_BF)
13350       opti_type |= OPTI_TYPE_BRUTE_FORCE;
13351
13352     data.opti_type = opti_type;
13353
13354     if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13355     {
13356       if (opti_type & OPTI_TYPE_SINGLE_HASH)
13357       {
13358         if (opti_type & OPTI_TYPE_APPENDED_SALT)
13359         {
13360           if (opts_type & OPTS_TYPE_ST_ADD80)
13361           {
13362             opts_type &= ~OPTS_TYPE_ST_ADD80;
13363             opts_type |=  OPTS_TYPE_PT_ADD80;
13364           }
13365
13366           if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13367           {
13368             opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13369             opts_type |=  OPTS_TYPE_PT_ADDBITS14;
13370           }
13371
13372           if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13373           {
13374             opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13375             opts_type |=  OPTS_TYPE_PT_ADDBITS15;
13376           }
13377         }
13378       }
13379     }
13380
13381     /**
13382      * Some algorithm, like descrypt, can benefit from JIT compilation
13383      */
13384
13385     int force_jit_compilation = -1;
13386
13387     if (hash_mode == 8900)
13388     {
13389       force_jit_compilation = 8900;
13390     }
13391     else if (hash_mode == 9300)
13392     {
13393       force_jit_compilation = 8900;
13394     }
13395     else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13396     {
13397       force_jit_compilation = 1500;
13398     }
13399
13400     /**
13401      * generate bitmap tables
13402      */
13403
13404     const uint bitmap_shift1 = 5;
13405     const uint bitmap_shift2 = 13;
13406
13407     if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13408
13409     uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13410     uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13411     uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13412     uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13413     uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13414     uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13415     uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13416     uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13417
13418     uint bitmap_bits;
13419     uint bitmap_nums;
13420     uint bitmap_mask;
13421     uint bitmap_size;
13422
13423     for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13424     {
13425       if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13426
13427       bitmap_nums = 1 << bitmap_bits;
13428
13429       bitmap_mask = bitmap_nums - 1;
13430
13431       bitmap_size = bitmap_nums * sizeof (uint);
13432
13433       if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13434
13435       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;
13436       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;
13437
13438       break;
13439     }
13440
13441     bitmap_nums = 1 << bitmap_bits;
13442
13443     bitmap_mask = bitmap_nums - 1;
13444
13445     bitmap_size = bitmap_nums * sizeof (uint);
13446
13447     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);
13448     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);
13449
13450     /**
13451      * prepare quick rule
13452      */
13453
13454     data.rule_buf_l = rule_buf_l;
13455     data.rule_buf_r = rule_buf_r;
13456
13457     int rule_len_l = (int) strlen (rule_buf_l);
13458     int rule_len_r = (int) strlen (rule_buf_r);
13459
13460     data.rule_len_l = rule_len_l;
13461     data.rule_len_r = rule_len_r;
13462
13463     /**
13464      * load rules
13465      */
13466
13467     uint *all_kernel_rules_cnt = NULL;
13468
13469     kernel_rule_t **all_kernel_rules_buf = NULL;
13470
13471     if (rp_files_cnt)
13472     {
13473       all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13474
13475       all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13476     }
13477
13478     char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13479
13480     int rule_len = 0;
13481
13482     for (uint i = 0; i < rp_files_cnt; i++)
13483     {
13484       uint kernel_rules_avail = 0;
13485
13486       uint kernel_rules_cnt = 0;
13487
13488       kernel_rule_t *kernel_rules_buf = NULL;
13489
13490       char *rp_file = rp_files[i];
13491
13492       char in[BLOCK_SIZE]  = { 0 };
13493       char out[BLOCK_SIZE] = { 0 };
13494
13495       FILE *fp = NULL;
13496
13497       uint rule_line = 0;
13498
13499       if ((fp = fopen (rp_file, "rb")) == NULL)
13500       {
13501         log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13502
13503         return (-1);
13504       }
13505
13506       while (!feof (fp))
13507       {
13508         memset (rule_buf, 0, HCBUFSIZ);
13509
13510         rule_len = fgetl (fp, rule_buf);
13511
13512         rule_line++;
13513
13514         if (rule_len == 0) continue;
13515
13516         if (rule_buf[0] == '#') continue;
13517
13518         if (kernel_rules_avail == kernel_rules_cnt)
13519         {
13520           kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13521
13522           kernel_rules_avail += INCR_RULES;
13523         }
13524
13525         memset (in,  0, BLOCK_SIZE);
13526         memset (out, 0, BLOCK_SIZE);
13527
13528         int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13529
13530         if (result == -1)
13531         {
13532           log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13533
13534           continue;
13535         }
13536
13537         if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13538         {
13539           log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13540
13541           memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13542
13543           continue;
13544         }
13545
13546         /* its so slow
13547         if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13548         {
13549           log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13550
13551           continue;
13552         }
13553         */
13554
13555         kernel_rules_cnt++;
13556       }
13557
13558       fclose (fp);
13559
13560       all_kernel_rules_cnt[i] = kernel_rules_cnt;
13561
13562       all_kernel_rules_buf[i] = kernel_rules_buf;
13563     }
13564
13565     /**
13566      * merge rules or automatic rule generator
13567      */
13568
13569     uint kernel_rules_cnt = 0;
13570
13571     kernel_rule_t *kernel_rules_buf = NULL;
13572
13573     if (attack_mode == ATTACK_MODE_STRAIGHT)
13574     {
13575       if (rp_files_cnt)
13576       {
13577         kernel_rules_cnt = 1;
13578
13579         uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13580
13581         repeats[0] = kernel_rules_cnt;
13582
13583         for (uint i = 0; i < rp_files_cnt; i++)
13584         {
13585           kernel_rules_cnt *= all_kernel_rules_cnt[i];
13586
13587           repeats[i + 1] = kernel_rules_cnt;
13588         }
13589
13590         kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13591
13592         memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13593
13594         for (uint i = 0; i < kernel_rules_cnt; i++)
13595         {
13596           uint out_pos = 0;
13597
13598           kernel_rule_t *out = &kernel_rules_buf[i];
13599
13600           for (uint j = 0; j < rp_files_cnt; j++)
13601           {
13602             uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13603             uint in_pos;
13604
13605             kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13606
13607             for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13608             {
13609               if (out_pos == RULES_MAX - 1)
13610               {
13611                 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13612
13613                 break;
13614               }
13615
13616               out->cmds[out_pos] = in->cmds[in_pos];
13617             }
13618           }
13619         }
13620
13621         local_free (repeats);
13622       }
13623       else if (rp_gen)
13624       {
13625         uint kernel_rules_avail = 0;
13626
13627         while (kernel_rules_cnt < rp_gen)
13628         {
13629           if (kernel_rules_avail == kernel_rules_cnt)
13630           {
13631             kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13632
13633             kernel_rules_avail += INCR_RULES;
13634           }
13635
13636           memset (rule_buf, 0, HCBUFSIZ);
13637
13638           rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13639
13640           if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13641
13642           kernel_rules_cnt++;
13643         }
13644       }
13645     }
13646
13647     myfree (rule_buf);
13648
13649     /**
13650      * generate NOP rules
13651      */
13652
13653     if (kernel_rules_cnt == 0)
13654     {
13655       kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13656
13657       kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13658
13659       kernel_rules_cnt++;
13660     }
13661
13662     data.kernel_rules_cnt = kernel_rules_cnt;
13663     data.kernel_rules_buf = kernel_rules_buf;
13664
13665     /**
13666      * OpenCL platforms: detect
13667      */
13668
13669     cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13670     cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13671
13672     cl_uint platforms_cnt = 0;
13673     cl_uint platform_devices_cnt = 0;
13674
13675     if (keyspace == 0)
13676     {
13677       hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13678
13679       if (platforms_cnt == 0)
13680       {
13681         log_info ("");
13682         log_info ("ATTENTION! No OpenCL compatible platform found");
13683         log_info ("");
13684         log_info ("You're probably missing the OpenCL runtime installation");
13685         log_info ("  AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13686         log_info ("  Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13687         log_info ("  NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13688         log_info ("");
13689
13690         return (-1);
13691       }
13692
13693       if (opencl_platforms_filter != (uint) -1)
13694       {
13695         uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13696
13697         if (opencl_platforms_filter > platform_cnt_mask)
13698         {
13699           log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13700
13701           return (-1);
13702         }
13703       }
13704     }
13705
13706     if (opencl_device_types == NULL)
13707     {
13708       /**
13709        * OpenCL device types:
13710        *   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.
13711        */
13712
13713       cl_device_type device_types_all = 0;
13714
13715       for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13716       {
13717         if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13718
13719         cl_platform_id platform = platforms[platform_id];
13720
13721         hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13722
13723         for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13724         {
13725           cl_device_id device = platform_devices[platform_devices_id];
13726
13727           cl_device_type device_type;
13728
13729           hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13730
13731           device_types_all |= device_type;
13732         }
13733       }
13734
13735       // In such a case, automatically enable CPU device type support, since it's disabled by default.
13736
13737       if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13738       {
13739         device_types_filter |= CL_DEVICE_TYPE_CPU;
13740       }
13741
13742       // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13743       // If we have a CPU device, force it to be used
13744
13745       if (stdout_flag == 1)
13746       {
13747         if (device_types_all & CL_DEVICE_TYPE_CPU)
13748         {
13749           device_types_filter = CL_DEVICE_TYPE_CPU;
13750         }
13751       }
13752     }
13753
13754     /**
13755      * OpenCL devices: simply push all devices from all platforms into the same device array
13756      */
13757
13758     int need_adl     = 0;
13759     int need_nvapi   = 0;
13760     int need_nvml    = 0;
13761     int need_xnvctrl = 0;
13762
13763     hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13764
13765     data.devices_param = devices_param;
13766
13767     uint devices_cnt = 0;
13768
13769     uint devices_active = 0;
13770
13771     for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
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       char platform_vendor[INFOSZ] = { 0 };
13778
13779       hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13780
13781       // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13782       // this causes trouble with vendor id based macros
13783       // we'll assign generic to those without special optimization available
13784
13785       cl_uint platform_vendor_id = 0;
13786
13787       if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13788       {
13789         platform_vendor_id = VENDOR_ID_AMD;
13790       }
13791       else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13792       {
13793         platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13794       }
13795       else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13796       {
13797         platform_vendor_id = VENDOR_ID_APPLE;
13798       }
13799       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13800       {
13801         platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13802       }
13803       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13804       {
13805         platform_vendor_id = VENDOR_ID_INTEL_SDK;
13806       }
13807       else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13808       {
13809         platform_vendor_id = VENDOR_ID_MESA;
13810       }
13811       else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13812       {
13813         platform_vendor_id = VENDOR_ID_NV;
13814       }
13815       else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13816       {
13817         platform_vendor_id = VENDOR_ID_POCL;
13818       }
13819       else
13820       {
13821         platform_vendor_id = VENDOR_ID_GENERIC;
13822       }
13823
13824       const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13825
13826       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13827       {
13828         if (machine_readable == 0)
13829         {
13830           if (platform_skipped == 0)
13831           {
13832             const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13833
13834             char line[256] = { 0 };
13835
13836             for (int i = 0; i < len; i++) line[i] = '=';
13837
13838             log_info (line);
13839           }
13840           else
13841           {
13842             log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13843             log_info ("");
13844           }
13845         }
13846       }
13847
13848       if (platform_skipped == 1) continue;
13849
13850       for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13851       {
13852         size_t param_value_size = 0;
13853
13854         const uint device_id = devices_cnt;
13855
13856         hc_device_param_t *device_param = &data.devices_param[device_id];
13857
13858         device_param->platform_vendor_id = platform_vendor_id;
13859
13860         device_param->device = platform_devices[platform_devices_id];
13861
13862         device_param->device_id = device_id;
13863
13864         device_param->platform_devices_id = platform_devices_id;
13865
13866         // device_type
13867
13868         cl_device_type device_type;
13869
13870         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13871
13872         device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13873
13874         device_param->device_type = device_type;
13875
13876         // device_name
13877
13878         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13879
13880         char *device_name = (char *) mymalloc (param_value_size);
13881
13882         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13883
13884         device_param->device_name = device_name;
13885
13886         // device_vendor
13887
13888         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13889
13890         char *device_vendor = (char *) mymalloc (param_value_size);
13891
13892         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13893
13894         device_param->device_vendor = device_vendor;
13895
13896         cl_uint device_vendor_id = 0;
13897
13898         if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13899         {
13900           device_vendor_id = VENDOR_ID_AMD;
13901         }
13902         else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13903         {
13904           device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13905         }
13906         else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13907         {
13908           device_vendor_id = VENDOR_ID_APPLE;
13909         }
13910         else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13911         {
13912           device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13913         }
13914         else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13915         {
13916           device_vendor_id = VENDOR_ID_INTEL_SDK;
13917         }
13918         else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13919         {
13920           device_vendor_id = VENDOR_ID_MESA;
13921         }
13922         else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13923         {
13924           device_vendor_id = VENDOR_ID_NV;
13925         }
13926         else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13927         {
13928           device_vendor_id = VENDOR_ID_POCL;
13929         }
13930         else
13931         {
13932           device_vendor_id = VENDOR_ID_GENERIC;
13933         }
13934
13935         device_param->device_vendor_id = device_vendor_id;
13936
13937         // tuning db
13938
13939         tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13940
13941         // device_version
13942
13943         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13944
13945         char *device_version = (char *) mymalloc (param_value_size);
13946
13947         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13948
13949         device_param->device_version = device_version;
13950
13951         // device_opencl_version
13952
13953         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13954
13955         char *device_opencl_version = (char *) mymalloc (param_value_size);
13956
13957         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13958
13959         device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13960
13961         myfree (device_opencl_version);
13962
13963         // vector_width
13964
13965         cl_uint vector_width;
13966
13967         if (opencl_vector_width_chgd == 0)
13968         {
13969           if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13970           {
13971             if (opti_type & OPTI_TYPE_USES_BITS_64)
13972             {
13973               hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13974             }
13975             else
13976             {
13977               hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,  sizeof (vector_width), &vector_width, NULL);
13978             }
13979           }
13980           else
13981           {
13982             vector_width = (cl_uint) tuningdb_entry->vector_width;
13983           }
13984         }
13985         else
13986         {
13987           vector_width = opencl_vector_width;
13988         }
13989
13990         if (vector_width > 16) vector_width = 16;
13991
13992         device_param->vector_width = vector_width;
13993
13994         // max_compute_units
13995
13996         cl_uint device_processors;
13997
13998         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13999
14000         device_param->device_processors = device_processors;
14001
14002         // device_maxmem_alloc
14003         // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14004
14005         cl_ulong device_maxmem_alloc;
14006
14007         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14008
14009         device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14010
14011         // device_global_mem
14012
14013         cl_ulong device_global_mem;
14014
14015         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14016
14017         device_param->device_global_mem = device_global_mem;
14018
14019         // max_work_group_size
14020
14021         size_t device_maxworkgroup_size;
14022
14023         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14024
14025         device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14026
14027         // max_clock_frequency
14028
14029         cl_uint device_maxclock_frequency;
14030
14031         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14032
14033         device_param->device_maxclock_frequency = device_maxclock_frequency;
14034
14035         // device_endian_little
14036
14037         cl_bool device_endian_little;
14038
14039         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14040
14041         if (device_endian_little == CL_FALSE)
14042         {
14043           log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14044
14045           device_param->skipped = 1;
14046         }
14047
14048         // device_available
14049
14050         cl_bool device_available;
14051
14052         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14053
14054         if (device_available == CL_FALSE)
14055         {
14056           log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14057
14058           device_param->skipped = 1;
14059         }
14060
14061         // device_compiler_available
14062
14063         cl_bool device_compiler_available;
14064
14065         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14066
14067         if (device_compiler_available == CL_FALSE)
14068         {
14069           log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14070
14071           device_param->skipped = 1;
14072         }
14073
14074         // device_execution_capabilities
14075
14076         cl_device_exec_capabilities device_execution_capabilities;
14077
14078         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14079
14080         if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14081         {
14082           log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14083
14084           device_param->skipped = 1;
14085         }
14086
14087         // device_extensions
14088
14089         size_t device_extensions_size;
14090
14091         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14092
14093         char *device_extensions = mymalloc (device_extensions_size + 1);
14094
14095         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14096
14097         if (strstr (device_extensions, "base_atomics") == 0)
14098         {
14099           log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14100
14101           device_param->skipped = 1;
14102         }
14103
14104         if (strstr (device_extensions, "byte_addressable_store") == 0)
14105         {
14106           log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14107
14108           device_param->skipped = 1;
14109         }
14110
14111         myfree (device_extensions);
14112
14113         // device_local_mem_size
14114
14115         cl_ulong device_local_mem_size;
14116
14117         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14118
14119         if (device_local_mem_size < 32768)
14120         {
14121           log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14122
14123           device_param->skipped = 1;
14124         }
14125
14126         // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14127         // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14128         // This results in both utilizing it for 50%
14129         // However, Intel has much better SIMD control over their own hardware
14130         // It makes sense to give them full control over their own hardware
14131
14132         if (device_type & CL_DEVICE_TYPE_CPU)
14133         {
14134           if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14135           {
14136             if (data.force == 0)
14137             {
14138               if (algorithm_pos == 0)
14139               {
14140                 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14141                 log_info ("             You can use --force to override this but do not post error reports if you do so");
14142               }
14143
14144               device_param->skipped = 1;
14145             }
14146           }
14147         }
14148
14149         // skipped
14150
14151         device_param->skipped |= ((devices_filter      & (1 << device_id)) == 0);
14152         device_param->skipped |= ((device_types_filter & (device_type))    == 0);
14153
14154         // driver_version
14155
14156         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14157
14158         char *driver_version = (char *) mymalloc (param_value_size);
14159
14160         hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14161
14162         device_param->driver_version = driver_version;
14163
14164         // device_name_chksum
14165
14166         char *device_name_chksum = (char *) mymalloc (INFOSZ);
14167
14168         #if __x86_64__
14169         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);
14170         #else
14171         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);
14172         #endif
14173
14174         uint device_name_digest[4] = { 0 };
14175
14176         md5_64 ((uint *) device_name_chksum, device_name_digest);
14177
14178         snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14179
14180         device_param->device_name_chksum = device_name_chksum;
14181
14182         // device_processor_cores
14183
14184         if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14185         {
14186           if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14187           {
14188             need_adl = 1;
14189           }
14190
14191           if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14192           {
14193             need_nvml = 1;
14194
14195             #ifdef LINUX
14196             need_xnvctrl = 1;
14197             #endif
14198
14199             #ifdef WIN
14200             need_nvapi = 1;
14201             #endif
14202           }
14203         }
14204
14205         // device_processor_cores
14206
14207         if (device_type & CL_DEVICE_TYPE_CPU)
14208         {
14209           cl_uint device_processor_cores = 1;
14210
14211           device_param->device_processor_cores = device_processor_cores;
14212         }
14213
14214         if (device_type & CL_DEVICE_TYPE_GPU)
14215         {
14216           if (device_vendor_id == VENDOR_ID_AMD)
14217           {
14218             cl_uint device_processor_cores = 0;
14219
14220             #define CL_DEVICE_WAVEFRONT_WIDTH_AMD               0x4043
14221
14222             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14223
14224             device_param->device_processor_cores = device_processor_cores;
14225           }
14226           else if (device_vendor_id == VENDOR_ID_NV)
14227           {
14228             cl_uint kernel_exec_timeout = 0;
14229
14230             #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV            0x4005
14231
14232             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14233
14234             device_param->kernel_exec_timeout = kernel_exec_timeout;
14235
14236             cl_uint device_processor_cores = 0;
14237
14238             #define CL_DEVICE_WARP_SIZE_NV                      0x4003
14239
14240             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14241
14242             device_param->device_processor_cores = device_processor_cores;
14243
14244             cl_uint sm_minor = 0;
14245             cl_uint sm_major = 0;
14246
14247             #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV       0x4000
14248             #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV       0x4001
14249
14250             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14251             hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14252
14253             device_param->sm_minor = sm_minor;
14254             device_param->sm_major = sm_major;
14255
14256             // CPU burning loop damper
14257             // Value is given as number between 0-100
14258             // By default 100%
14259
14260             device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14261
14262             if (nvidia_spin_damp_chgd == 0)
14263             {
14264               if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14265               {
14266                 /**
14267                  * the workaround is not a friend of rule based attacks
14268                  * the words from the wordlist combined with fast and slow rules cause
14269                  * fluctuations which cause inaccurate wait time estimations
14270                  * using a reduced damping percentage almost compensates this
14271                  */
14272
14273                 device_param->nvidia_spin_damp = 64;
14274               }
14275             }
14276
14277             device_param->nvidia_spin_damp /= 100;
14278           }
14279           else
14280           {
14281             cl_uint device_processor_cores = 1;
14282
14283             device_param->device_processor_cores = device_processor_cores;
14284           }
14285         }
14286
14287         // display results
14288
14289         if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14290         {
14291           if (machine_readable == 0)
14292           {
14293             if (device_param->skipped == 0)
14294             {
14295               log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14296                         device_id + 1,
14297                         device_name,
14298                         (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14299                         (unsigned int) (device_global_mem   / 1024 / 1024),
14300                         (unsigned int)  device_processors);
14301             }
14302             else
14303             {
14304               log_info ("- Device #%u: %s, skipped",
14305                         device_id + 1,
14306                         device_name);
14307             }
14308           }
14309         }
14310
14311         // common driver check
14312
14313         if (device_param->skipped == 0)
14314         {
14315           if (device_type & CL_DEVICE_TYPE_GPU)
14316           {
14317             if (platform_vendor_id == VENDOR_ID_AMD)
14318             {
14319               int catalyst_check = (force == 1) ? 0 : 1;
14320
14321               int catalyst_warn = 0;
14322
14323               int catalyst_broken = 0;
14324
14325               if (catalyst_check == 1)
14326               {
14327                 catalyst_warn = 1;
14328
14329                 // v14.9 and higher
14330                 if (atoi (device_param->driver_version) >= 1573)
14331                 {
14332                   catalyst_warn = 0;
14333                 }
14334
14335                 catalyst_check = 0;
14336               }
14337
14338               if (catalyst_broken == 1)
14339               {
14340                 log_info ("");
14341                 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14342                 log_info ("It passes over cracked hashes and will not report them as cracked");
14343                 log_info ("You are STRONGLY encouraged not to use it");
14344                 log_info ("You can use --force to override this but do not post error reports if you do so");
14345                 log_info ("");
14346
14347                 return (-1);
14348               }
14349
14350               if (catalyst_warn == 1)
14351               {
14352                 log_info ("");
14353                 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14354                 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14355                 log_info ("See hashcat's homepage for official supported catalyst drivers");
14356                 #ifdef _WIN
14357                 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14358                 #endif
14359                 log_info ("You can use --force to override this but do not post error reports if you do so");
14360                 log_info ("");
14361
14362                 return (-1);
14363               }
14364             }
14365             else if (platform_vendor_id == VENDOR_ID_NV)
14366             {
14367               if (device_param->kernel_exec_timeout != 0)
14368               {
14369                 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);
14370                 if (data.quiet == 0) log_info ("             See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14371               }
14372             }
14373           }
14374
14375           /* turns out pocl still creates segfaults (because of llvm)
14376           if (device_type & CL_DEVICE_TYPE_CPU)
14377           {
14378             if (platform_vendor_id == VENDOR_ID_AMD)
14379             {
14380               if (force == 0)
14381               {
14382                 log_info ("");
14383                 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14384                 log_info ("You are STRONGLY encouraged not to use it");
14385                 log_info ("You can use --force to override this but do not post error reports if you do so");
14386                 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14387                 log_info ("");
14388
14389                 return (-1);
14390               }
14391             }
14392           }
14393           */
14394
14395           /**
14396            * kernel accel and loops tuning db adjustment
14397            */
14398
14399           device_param->kernel_accel_min = 1;
14400           device_param->kernel_accel_max = 1024;
14401
14402           device_param->kernel_loops_min = 1;
14403           device_param->kernel_loops_max = 1024;
14404
14405           tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14406
14407           if (tuningdb_entry)
14408           {
14409             u32 _kernel_accel = tuningdb_entry->kernel_accel;
14410             u32 _kernel_loops = tuningdb_entry->kernel_loops;
14411
14412             if (_kernel_accel)
14413             {
14414               device_param->kernel_accel_min = _kernel_accel;
14415               device_param->kernel_accel_max = _kernel_accel;
14416             }
14417
14418             if (_kernel_loops)
14419             {
14420               if (workload_profile == 1)
14421               {
14422                 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14423               }
14424               else if (workload_profile == 2)
14425               {
14426                 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14427               }
14428
14429               device_param->kernel_loops_min = _kernel_loops;
14430               device_param->kernel_loops_max = _kernel_loops;
14431             }
14432           }
14433
14434           // commandline parameters overwrite tuningdb entries
14435
14436           if (kernel_accel)
14437           {
14438             device_param->kernel_accel_min = kernel_accel;
14439             device_param->kernel_accel_max = kernel_accel;
14440           }
14441
14442           if (kernel_loops)
14443           {
14444             device_param->kernel_loops_min = kernel_loops;
14445             device_param->kernel_loops_max = kernel_loops;
14446           }
14447
14448           /**
14449            * activate device
14450            */
14451
14452           devices_active++;
14453         }
14454
14455         // next please
14456
14457         devices_cnt++;
14458       }
14459
14460       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14461       {
14462         if (machine_readable == 0)
14463         {
14464           log_info ("");
14465         }
14466       }
14467     }
14468
14469     if (keyspace == 0 && devices_active == 0)
14470     {
14471       log_error ("ERROR: No devices found/left");
14472
14473       return (-1);
14474     }
14475
14476     // 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)
14477
14478     if (devices_filter != (uint) -1)
14479     {
14480       uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14481
14482       if (devices_filter > devices_cnt_mask)
14483       {
14484         log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14485
14486         return (-1);
14487       }
14488     }
14489
14490     data.devices_cnt = devices_cnt;
14491
14492     data.devices_active = devices_active;
14493
14494     /**
14495      * HM devices: init
14496      */
14497
14498     #ifdef HAVE_HWMON
14499     hm_attrs_t hm_adapters_adl[DEVICES_MAX]     = { { 0 } };
14500     hm_attrs_t hm_adapters_nvapi[DEVICES_MAX]   = { { 0 } };
14501     hm_attrs_t hm_adapters_nvml[DEVICES_MAX]    = { { 0 } };
14502     hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14503
14504     if (gpu_temp_disable == 0)
14505     {
14506       ADL_PTR     *adl     = (ADL_PTR *)     mymalloc (sizeof (ADL_PTR));
14507       NVAPI_PTR   *nvapi   = (NVAPI_PTR *)   mymalloc (sizeof (NVAPI_PTR));
14508       NVML_PTR    *nvml    = (NVML_PTR *)    mymalloc (sizeof (NVML_PTR));
14509       XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14510
14511       data.hm_adl     = NULL;
14512       data.hm_nvapi   = NULL;
14513       data.hm_nvml    = NULL;
14514       data.hm_xnvctrl = NULL;
14515
14516       if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14517       {
14518         data.hm_nvml = nvml;
14519       }
14520
14521       if (data.hm_nvml)
14522       {
14523         if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14524         {
14525           HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14526
14527           int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14528
14529           int tmp_out = 0;
14530
14531           for (int i = 0; i < tmp_in; i++)
14532           {
14533             hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14534           }
14535
14536           for (int i = 0; i < tmp_out; i++)
14537           {
14538             unsigned int speed;
14539
14540             if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14541
14542             hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14543
14544             hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14545           }
14546         }
14547       }
14548
14549       if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14550       {
14551         data.hm_nvapi = nvapi;
14552       }
14553
14554       if (data.hm_nvapi)
14555       {
14556         if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14557         {
14558           HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14559
14560           int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14561
14562           int tmp_out = 0;
14563
14564           for (int i = 0; i < tmp_in; i++)
14565           {
14566             hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14567           }
14568         }
14569       }
14570
14571       if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14572       {
14573         data.hm_xnvctrl = xnvctrl;
14574       }
14575
14576       if (data.hm_xnvctrl)
14577       {
14578         if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14579         {
14580           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14581           {
14582             hc_device_param_t *device_param = &data.devices_param[device_id];
14583
14584             if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14585
14586             hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14587
14588             int speed = 0;
14589
14590             if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14591           }
14592         }
14593       }
14594
14595       if ((need_adl == 1) && (adl_init (adl) == 0))
14596       {
14597         data.hm_adl = adl;
14598       }
14599
14600       if (data.hm_adl)
14601       {
14602         if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14603         {
14604           // total number of adapters
14605
14606           int hm_adapters_num;
14607
14608           if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14609
14610           // adapter info
14611
14612           LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14613
14614           if (lpAdapterInfo == NULL) return (-1);
14615
14616           // get a list (of ids of) valid/usable adapters
14617
14618           int num_adl_adapters = 0;
14619
14620           u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14621
14622           if (num_adl_adapters > 0)
14623           {
14624             hc_thread_mutex_lock (mux_adl);
14625
14626             // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14627
14628             hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14629
14630             hm_get_overdrive_version  (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14631             hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14632
14633             hc_thread_mutex_unlock (mux_adl);
14634           }
14635
14636           myfree (valid_adl_device_list);
14637           myfree (lpAdapterInfo);
14638         }
14639       }
14640
14641       if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14642       {
14643         gpu_temp_disable = 1;
14644       }
14645     }
14646
14647     /**
14648      * OpenCL devices: allocate buffer for device specific information
14649      */
14650
14651     int *temp_retain_fanspeed_value  = (int *) mycalloc (data.devices_cnt, sizeof (int));
14652     int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14653
14654     ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14655
14656     int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14657
14658     unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14659
14660     /**
14661      * User-defined GPU temp handling
14662      */
14663
14664     if (gpu_temp_disable == 1)
14665     {
14666       gpu_temp_abort  = 0;
14667       gpu_temp_retain = 0;
14668     }
14669
14670     if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14671     {
14672       if (gpu_temp_abort < gpu_temp_retain)
14673       {
14674         log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14675
14676         return (-1);
14677       }
14678     }
14679
14680     data.gpu_temp_disable = gpu_temp_disable;
14681     data.gpu_temp_abort   = gpu_temp_abort;
14682     data.gpu_temp_retain  = gpu_temp_retain;
14683     #endif
14684
14685     /**
14686      * enable custom signal handler(s)
14687      */
14688
14689     if (benchmark == 0)
14690     {
14691       hc_signal (sigHandler_default);
14692     }
14693     else
14694     {
14695       hc_signal (sigHandler_benchmark);
14696     }
14697
14698     /**
14699      * inform the user
14700      */
14701
14702     if (data.quiet == 0)
14703     {
14704       log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14705
14706       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);
14707
14708       if (attack_mode == ATTACK_MODE_STRAIGHT)
14709       {
14710         log_info ("Rules: %u", kernel_rules_cnt);
14711       }
14712
14713       if (opti_type)
14714       {
14715         log_info ("Applicable Optimizers:");
14716
14717         for (uint i = 0; i < 32; i++)
14718         {
14719           const uint opti_bit = 1u << i;
14720
14721           if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14722         }
14723       }
14724
14725       /**
14726        * Watchdog and Temperature balance
14727        */
14728
14729       #ifdef HAVE_HWMON
14730       if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14731       {
14732         log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14733       }
14734
14735       if (gpu_temp_abort == 0)
14736       {
14737         log_info ("Watchdog: Temperature abort trigger disabled");
14738       }
14739       else
14740       {
14741         log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14742       }
14743
14744       if (gpu_temp_retain == 0)
14745       {
14746         log_info ("Watchdog: Temperature retain trigger disabled");
14747       }
14748       else
14749       {
14750         log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14751       }
14752
14753       if (data.quiet == 0) log_info ("");
14754       #endif
14755     }
14756
14757     #ifdef HAVE_HWMON
14758
14759     /**
14760      * HM devices: copy
14761      */
14762
14763     if (gpu_temp_disable == 0)
14764     {
14765       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14766       {
14767         hc_device_param_t *device_param = &data.devices_param[device_id];
14768
14769         if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14770
14771         if (device_param->skipped) continue;
14772
14773         const uint platform_devices_id = device_param->platform_devices_id;
14774
14775         if (device_param->device_vendor_id == VENDOR_ID_AMD)
14776         {
14777           data.hm_device[device_id].adl               = hm_adapters_adl[platform_devices_id].adl;
14778           data.hm_device[device_id].nvapi             = 0;
14779           data.hm_device[device_id].nvml              = 0;
14780           data.hm_device[device_id].xnvctrl           = 0;
14781           data.hm_device[device_id].od_version        = hm_adapters_adl[platform_devices_id].od_version;
14782           data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14783           data.hm_device[device_id].fan_set_supported = 0;
14784         }
14785
14786         if (device_param->device_vendor_id == VENDOR_ID_NV)
14787         {
14788           data.hm_device[device_id].adl               = 0;
14789           data.hm_device[device_id].nvapi             = hm_adapters_nvapi[platform_devices_id].nvapi;
14790           data.hm_device[device_id].nvml              = hm_adapters_nvml[platform_devices_id].nvml;
14791           data.hm_device[device_id].xnvctrl           = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14792           data.hm_device[device_id].od_version        = 0;
14793           data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14794           data.hm_device[device_id].fan_set_supported = 0;
14795         }
14796       }
14797     }
14798
14799     /**
14800      * powertune on user request
14801      */
14802
14803     if (powertune_enable == 1)
14804     {
14805       hc_thread_mutex_lock (mux_adl);
14806
14807       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14808       {
14809         hc_device_param_t *device_param = &data.devices_param[device_id];
14810
14811         if (device_param->skipped) continue;
14812
14813         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14814         {
14815           /**
14816            * Temporary fix:
14817            * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14818            * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14819            * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14820            * Driver / ADL bug?
14821            */
14822
14823           if (data.hm_device[device_id].od_version == 6)
14824           {
14825             int ADL_rc;
14826
14827             // check powertune capabilities first, if not available then skip device
14828
14829             int powertune_supported = 0;
14830
14831             if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14832             {
14833               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14834
14835               return (-1);
14836             }
14837
14838             // first backup current value, we will restore it later
14839
14840             if (powertune_supported != 0)
14841             {
14842               // powercontrol settings
14843
14844               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14845
14846               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14847               {
14848                 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14849               }
14850
14851               if (ADL_rc != ADL_OK)
14852               {
14853                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14854
14855                 return (-1);
14856               }
14857
14858               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14859               {
14860                 log_error ("ERROR: Failed to set new ADL PowerControl values");
14861
14862                 return (-1);
14863               }
14864
14865               // clocks
14866
14867               memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14868
14869               od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14870
14871               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)
14872               {
14873                 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14874
14875                 return (-1);
14876               }
14877
14878               // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14879
14880               ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14881
14882               if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14883               {
14884                 log_error ("ERROR: Failed to get ADL device capabilities");
14885
14886                 return (-1);
14887               }
14888
14889               int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14890               int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14891
14892               int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14893               int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14894
14895               int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14896               int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14897
14898               // warning if profile has too low max values
14899
14900               if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14901               {
14902                 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14903               }
14904
14905               if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14906               {
14907                 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14908               }
14909
14910               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14911
14912               performance_state->iNumberOfPerformanceLevels = 2;
14913
14914               performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14915               performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14916               performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14917               performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14918
14919               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)
14920               {
14921                 log_info ("ERROR: Failed to set ADL performance state");
14922
14923                 return (-1);
14924               }
14925
14926               local_free (performance_state);
14927             }
14928
14929             // set powertune value only
14930
14931             if (powertune_supported != 0)
14932             {
14933               // powertune set
14934               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14935
14936               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14937               {
14938                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14939
14940                 return (-1);
14941               }
14942
14943               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14944               {
14945                 log_error ("ERROR: Failed to set new ADL PowerControl values");
14946
14947                 return (-1);
14948               }
14949             }
14950           }
14951         }
14952
14953         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14954         {
14955           // first backup current value, we will restore it later
14956
14957           unsigned int limit;
14958
14959           int powertune_supported = 0;
14960
14961           if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14962           {
14963             powertune_supported = 1;
14964           }
14965
14966           // if backup worked, activate the maximum allowed
14967
14968           if (powertune_supported != 0)
14969           {
14970             unsigned int minLimit;
14971             unsigned int maxLimit;
14972
14973             if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14974             {
14975               if (maxLimit > 0)
14976               {
14977                 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14978                 {
14979                   // now we can be sure we need to reset later
14980
14981                   nvml_power_limit[device_id] = limit;
14982                 }
14983               }
14984             }
14985           }
14986         }
14987       }
14988
14989       hc_thread_mutex_unlock (mux_adl);
14990     }
14991
14992     #endif // HAVE_HWMON
14993
14994     #ifdef DEBUG
14995     if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14996     #endif
14997
14998     if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14999
15000     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15001     {
15002       /**
15003        * host buffer
15004        */
15005
15006       hc_device_param_t *device_param = &data.devices_param[device_id];
15007
15008       if (device_param->skipped) continue;
15009
15010       /**
15011        * device properties
15012        */
15013
15014       const char *device_name_chksum      = device_param->device_name_chksum;
15015       const u32   device_processors       = device_param->device_processors;
15016       const u32   device_processor_cores  = device_param->device_processor_cores;
15017
15018       /**
15019        * create context for each device
15020        */
15021
15022       device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15023
15024       /**
15025        * create command-queue
15026        */
15027
15028       // not supported with NV
15029       // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15030
15031       device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15032
15033       /**
15034        * kernel threads: some algorithms need a fixed kernel-threads count
15035        *                 because of shared memory usage or bitslice
15036        *                 there needs to be some upper limit, otherwise there's too much overhead
15037        */
15038
15039       uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15040
15041       if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15042       {
15043         kernel_threads = KERNEL_THREADS_MAX_CPU;
15044       }
15045
15046       if (hash_mode ==  1500) kernel_threads = 64; // DES
15047       if (hash_mode ==  3000) kernel_threads = 64; // DES
15048       if (hash_mode ==  3200) kernel_threads = 8;  // Blowfish
15049       if (hash_mode ==  7500) kernel_threads = 64; // RC4
15050       if (hash_mode ==  9000) kernel_threads = 8;  // Blowfish
15051       if (hash_mode ==  9700) kernel_threads = 64; // RC4
15052       if (hash_mode ==  9710) kernel_threads = 64; // RC4
15053       if (hash_mode ==  9800) kernel_threads = 64; // RC4
15054       if (hash_mode ==  9810) kernel_threads = 64; // RC4
15055       if (hash_mode == 10400) kernel_threads = 64; // RC4
15056       if (hash_mode == 10410) kernel_threads = 64; // RC4
15057       if (hash_mode == 10500) kernel_threads = 64; // RC4
15058       if (hash_mode == 13100) kernel_threads = 64; // RC4
15059
15060       device_param->kernel_threads = kernel_threads;
15061
15062       device_param->hardware_power = device_processors * kernel_threads;
15063
15064       /**
15065        * create input buffers on device : calculate size of fixed memory buffers
15066        */
15067
15068       size_t size_root_css   = SP_PW_MAX *           sizeof (cs_t);
15069       size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15070
15071       device_param->size_root_css   = size_root_css;
15072       device_param->size_markov_css = size_markov_css;
15073
15074       size_t size_results = sizeof (uint);
15075
15076       device_param->size_results = size_results;
15077
15078       size_t size_rules   = kernel_rules_cnt * sizeof (kernel_rule_t);
15079       size_t size_rules_c = KERNEL_RULES     * sizeof (kernel_rule_t);
15080
15081       size_t size_plains  = digests_cnt * sizeof (plain_t);
15082       size_t size_salts   = salts_cnt   * sizeof (salt_t);
15083       size_t size_esalts  = salts_cnt   * esalt_size;
15084
15085       device_param->size_plains   = size_plains;
15086       device_param->size_digests  = size_digests;
15087       device_param->size_shown    = size_shown;
15088       device_param->size_salts    = size_salts;
15089
15090       size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15091       size_t size_bfs   = KERNEL_BFS   * sizeof (bf_t);
15092       size_t size_tm    = 32           * sizeof (bs_word_t);
15093
15094       // scryptV stuff
15095
15096       size_t size_scryptV = 1;
15097
15098       if ((hash_mode == 8900) || (hash_mode == 9300))
15099       {
15100         uint tmto_start = 0;
15101         uint tmto_stop  = 10;
15102
15103         if (scrypt_tmto)
15104         {
15105           tmto_start = scrypt_tmto;
15106         }
15107         else
15108         {
15109           // in case the user did not specify the tmto manually
15110           // use some values known to run best (tested on 290x for AMD and 980ti for NV)
15111           // but set the lower end only in case the user has a device with too less memory
15112
15113           if (hash_mode == 8900)
15114           {
15115             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15116             {
15117               tmto_start = 1;
15118             }
15119             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15120             {
15121               tmto_start = 2;
15122             }
15123           }
15124           else if (hash_mode == 9300)
15125           {
15126             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15127             {
15128               tmto_start = 2;
15129             }
15130             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15131             {
15132               tmto_start = 2;
15133             }
15134           }
15135         }
15136
15137         for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
15138         {
15139           // TODO: in theory the following calculation needs to be done per salt, not global
15140           //       we assume all hashes have the same scrypt settings
15141
15142           size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
15143
15144           size_scryptV /= 1 << tmto;
15145
15146           size_scryptV *= device_processors * device_processor_cores;
15147
15148           if (size_scryptV > device_param->device_maxmem_alloc)
15149           {
15150             if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15151
15152             continue;
15153           }
15154
15155           for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15156           {
15157             data.salts_buf[salts_pos].scrypt_tmto = tmto;
15158             data.salts_buf[salts_pos].scrypt_phy  = device_processors * device_processor_cores;
15159           }
15160
15161           break;
15162         }
15163
15164         if (data.salts_buf[0].scrypt_phy == 0)
15165         {
15166           log_error ("ERROR: Can't allocate enough device memory");
15167
15168           return -1;
15169         }
15170
15171         if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
15172       }
15173
15174       /**
15175        * some algorithms need a fixed kernel-loops count
15176        */
15177
15178       if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15179       {
15180         const u32 kernel_loops_fixed = 1024;
15181
15182         device_param->kernel_loops_min = kernel_loops_fixed;
15183         device_param->kernel_loops_max = kernel_loops_fixed;
15184       }
15185
15186       if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15187       {
15188         const u32 kernel_loops_fixed = 1024;
15189
15190         device_param->kernel_loops_min = kernel_loops_fixed;
15191         device_param->kernel_loops_max = kernel_loops_fixed;
15192       }
15193
15194       if (hash_mode == 8900)
15195       {
15196         const u32 kernel_loops_fixed = 1;
15197
15198         device_param->kernel_loops_min = kernel_loops_fixed;
15199         device_param->kernel_loops_max = kernel_loops_fixed;
15200       }
15201
15202       if (hash_mode == 9300)
15203       {
15204         const u32 kernel_loops_fixed = 1;
15205
15206         device_param->kernel_loops_min = kernel_loops_fixed;
15207         device_param->kernel_loops_max = kernel_loops_fixed;
15208       }
15209
15210       if (hash_mode == 12500)
15211       {
15212         const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15213
15214         device_param->kernel_loops_min = kernel_loops_fixed;
15215         device_param->kernel_loops_max = kernel_loops_fixed;
15216       }
15217
15218       /**
15219        * some algorithms have a maximum kernel-loops count
15220        */
15221
15222       if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15223       {
15224         u32 innerloop_cnt = 0;
15225
15226         if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15227         {
15228           if      (data.attack_kern == ATTACK_KERN_STRAIGHT)  innerloop_cnt = data.kernel_rules_cnt;
15229           else if (data.attack_kern == ATTACK_KERN_COMBI)     innerloop_cnt = data.combs_cnt;
15230           else if (data.attack_kern == ATTACK_KERN_BF)        innerloop_cnt = data.bfs_cnt;
15231         }
15232         else
15233         {
15234           innerloop_cnt = data.salts_buf[0].salt_iter;
15235         }
15236
15237         if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15238             (innerloop_cnt <= device_param->kernel_loops_max))
15239         {
15240           device_param->kernel_loops_max = innerloop_cnt;
15241         }
15242       }
15243
15244       u32 kernel_accel_min = device_param->kernel_accel_min;
15245       u32 kernel_accel_max = device_param->kernel_accel_max;
15246
15247       // find out if we would request too much memory on memory blocks which are based on kernel_accel
15248
15249       size_t size_pws   = 4;
15250       size_t size_tmps  = 4;
15251       size_t size_hooks = 4;
15252
15253       while (kernel_accel_max >= kernel_accel_min)
15254       {
15255         const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15256
15257         // size_pws
15258
15259         size_pws = kernel_power_max * sizeof (pw_t);
15260
15261         // size_tmps
15262
15263         switch (hash_mode)
15264         {
15265           case   400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t);          break;
15266           case   500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15267           case   501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15268           case  1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15269           case  1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t);     break;
15270           case  2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t);            break;
15271           case  2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t);             break;
15272           case  3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t);          break;
15273           case  5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t);         break;
15274           case  5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t);      break;
15275           case  6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15276           case  6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15277           case  6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15278           case  6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15279           case  6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15280           case  6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15281           case  6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15282           case  6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15283           case  6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15284           case  6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15285           case  6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15286           case  6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15287           case  6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15288           case  6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t);       break;
15289           case  6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t);       break;
15290           case  6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t);        break;
15291           case  6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t);         break;
15292           case  6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t);        break;
15293           case  7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15294           case  7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15295           case  7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t);     break;
15296           case  7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t);         break;
15297           case  8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15298           case  8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t);      break;
15299           case  8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t);          break;
15300           case  9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t);         break;
15301           case  9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t);          break;
15302           case  9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15303           case  9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t);          break;
15304           case  9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t);      break;
15305           case  9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t);      break;
15306           case  9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t);      break;
15307           case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15308           case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t);            break;
15309           case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t);       break;
15310           case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t);           break;
15311           case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t);         break;
15312           case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15313           case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t);  break;
15314           case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t);       break;
15315           case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t);      break;
15316           case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15317           case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15318           case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t);        break;
15319           case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t);         break;
15320           case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t);       break;
15321           case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t);            break;
15322           case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t);        break;
15323           case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15324           case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15325           case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15326           case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t);         break;
15327           case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t);         break;
15328           case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15329           case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15330           case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15331           case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15332           case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15333           case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15334           case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15335           case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15336           case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15337           case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15338           case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15339           case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15340           case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15341           case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15342           case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15343           case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15344           case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15345           case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15346           case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15347         };
15348
15349         // size_hooks
15350
15351         if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15352         {
15353           switch (hash_mode)
15354           {
15355           }
15356         }
15357
15358         // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15359         // if not, decrease amplifier and try again
15360
15361         int memory_limit_hit = 0;
15362
15363         if (size_pws   > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15364         if (size_tmps  > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15365         if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15366
15367         const u64 size_total
15368           = bitmap_size
15369           + bitmap_size
15370           + bitmap_size
15371           + bitmap_size
15372           + bitmap_size
15373           + bitmap_size
15374           + bitmap_size
15375           + bitmap_size
15376           + size_bfs
15377           + size_combs
15378           + size_digests
15379           + size_esalts
15380           + size_hooks
15381           + size_markov_css
15382           + size_plains
15383           + size_pws
15384           + size_pws // not a bug
15385           + size_results
15386           + size_root_css
15387           + size_rules
15388           + size_rules_c
15389           + size_salts
15390           + size_scryptV
15391           + size_shown
15392           + size_tm
15393           + size_tmps;
15394
15395         if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15396
15397         if (memory_limit_hit == 1)
15398         {
15399           kernel_accel_max--;
15400
15401           continue;
15402         }
15403
15404         break;
15405       }
15406
15407       if (kernel_accel_max < kernel_accel_min)
15408       {
15409         log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15410
15411         return -1;
15412       }
15413
15414       device_param->kernel_accel_min = kernel_accel_min;
15415       device_param->kernel_accel_max = kernel_accel_max;
15416
15417       /*
15418       if (kernel_accel_max < kernel_accel)
15419       {
15420         if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15421
15422         device_param->kernel_accel = kernel_accel_max;
15423       }
15424       */
15425
15426       device_param->size_bfs     = size_bfs;
15427       device_param->size_combs   = size_combs;
15428       device_param->size_rules   = size_rules;
15429       device_param->size_rules_c = size_rules_c;
15430       device_param->size_pws     = size_pws;
15431       device_param->size_tmps    = size_tmps;
15432       device_param->size_hooks   = size_hooks;
15433
15434       /**
15435        * default building options
15436        */
15437
15438       char cpath[1024] = { 0 };
15439
15440       char build_opts[1024] = { 0 };
15441
15442       #if _WIN
15443
15444       snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15445
15446       char *cpath_real = mymalloc (MAX_PATH);
15447
15448       if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15449       {
15450         log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15451
15452         return -1;
15453       }
15454
15455       naive_replace (cpath_real, '\\', '/');
15456
15457       // not escaping here, windows has quotes
15458
15459       snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15460
15461       myfree (cpath_real);
15462
15463       #else
15464
15465       snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15466
15467       char *cpath_real = mymalloc (PATH_MAX);
15468
15469       if (realpath (cpath, cpath_real) == NULL)
15470       {
15471         log_error ("ERROR: %s: %s", cpath, strerror (errno));
15472
15473         return -1;
15474       }
15475
15476       naive_escape (cpath_real, PATH_MAX,  ' ', '\\');
15477
15478       snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15479
15480       myfree (cpath_real);
15481
15482       #endif
15483
15484       // we don't have sm_* on vendors not NV but it doesn't matter
15485
15486       char build_opts_new[1024] = { 0 };
15487
15488       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 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, kern_type);
15489
15490       strncpy (build_opts, build_opts_new, sizeof (build_opts));
15491
15492       #ifdef DEBUG
15493       log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15494       #endif
15495
15496       /**
15497        * main kernel
15498        */
15499
15500       {
15501         /**
15502          * kernel source filename
15503          */
15504
15505         char source_file[256] = { 0 };
15506
15507         generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15508
15509         struct stat sst;
15510
15511         if (stat (source_file, &sst) == -1)
15512         {
15513           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15514
15515           return -1;
15516         }
15517
15518         /**
15519          * kernel cached filename
15520          */
15521
15522         char cached_file[256] = { 0 };
15523
15524         generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15525
15526         int cached = 1;
15527
15528         struct stat cst;
15529
15530         if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15531         {
15532           cached = 0;
15533         }
15534
15535         /**
15536          * kernel compile or load
15537          */
15538
15539         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15540
15541         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15542
15543         if (force_jit_compilation == -1)
15544         {
15545           if (cached == 0)
15546           {
15547             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));
15548
15549             load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15550
15551             device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15552
15553             int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15554
15555             #ifdef DEBUG
15556             size_t build_log_size = 0;
15557
15558             hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15559
15560             if (build_log_size > 1)
15561             {
15562               char *build_log = (char *) malloc (build_log_size + 1);
15563
15564               memset (build_log, 0, build_log_size + 1);
15565
15566               hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15567
15568               puts (build_log);
15569
15570               free (build_log);
15571             }
15572             #endif
15573
15574             if (rc != 0)
15575             {
15576               device_param->skipped = true;
15577
15578               log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15579
15580               continue;
15581             }
15582
15583             size_t binary_size;
15584
15585             hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15586
15587             u8 *binary = (u8 *) mymalloc (binary_size);
15588
15589             hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15590
15591             writeProgramBin (cached_file, binary, binary_size);
15592
15593             local_free (binary);
15594           }
15595           else
15596           {
15597             #ifdef DEBUG
15598             log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15599             #endif
15600
15601             load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15602
15603             device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15604
15605             hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15606           }
15607         }
15608         else
15609         {
15610           #ifdef DEBUG
15611           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15612           #endif
15613
15614           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15615
15616           device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15617
15618           char build_opts_update[1024] = { 0 };
15619
15620           if (force_jit_compilation == 1500)
15621           {
15622             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15623           }
15624           else if (force_jit_compilation == 8900)
15625           {
15626             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15627           }
15628           else
15629           {
15630             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15631           }
15632
15633           int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15634
15635           #ifdef DEBUG
15636           size_t build_log_size = 0;
15637
15638           hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15639
15640           if (build_log_size > 1)
15641           {
15642             char *build_log = (char *) malloc (build_log_size + 1);
15643
15644             memset (build_log, 0, build_log_size + 1);
15645
15646             hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15647
15648             puts (build_log);
15649
15650             free (build_log);
15651           }
15652           #endif
15653
15654           if (rc != 0)
15655           {
15656             device_param->skipped = true;
15657
15658             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15659           }
15660         }
15661
15662         local_free (kernel_lengths);
15663         local_free (kernel_sources[0]);
15664         local_free (kernel_sources);
15665       }
15666
15667       /**
15668        * word generator kernel
15669        */
15670
15671       if (attack_mode != ATTACK_MODE_STRAIGHT)
15672       {
15673         /**
15674          * kernel mp source filename
15675          */
15676
15677         char source_file[256] = { 0 };
15678
15679         generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15680
15681         struct stat sst;
15682
15683         if (stat (source_file, &sst) == -1)
15684         {
15685           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15686
15687           return -1;
15688         }
15689
15690         /**
15691          * kernel mp cached filename
15692          */
15693
15694         char cached_file[256] = { 0 };
15695
15696         generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15697
15698         int cached = 1;
15699
15700         struct stat cst;
15701
15702         if (stat (cached_file, &cst) == -1)
15703         {
15704           cached = 0;
15705         }
15706
15707         /**
15708          * kernel compile or load
15709          */
15710
15711         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15712
15713         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15714
15715         if (cached == 0)
15716         {
15717           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));
15718           if (quiet == 0) log_info ("");
15719
15720           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15721
15722           device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15723
15724           int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15725
15726           if (rc != 0)
15727           {
15728             device_param->skipped = true;
15729
15730             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15731
15732             continue;
15733           }
15734
15735           size_t binary_size;
15736
15737           hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15738
15739           u8 *binary = (u8 *) mymalloc (binary_size);
15740
15741           hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15742
15743           writeProgramBin (cached_file, binary, binary_size);
15744
15745           local_free (binary);
15746         }
15747         else
15748         {
15749           #ifdef DEBUG
15750           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15751           #endif
15752
15753           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15754
15755           device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15756
15757           hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15758         }
15759
15760         local_free (kernel_lengths);
15761         local_free (kernel_sources[0]);
15762         local_free (kernel_sources);
15763       }
15764
15765       /**
15766        * amplifier kernel
15767        */
15768
15769       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15770       {
15771
15772       }
15773       else
15774       {
15775         /**
15776          * kernel amp source filename
15777          */
15778
15779         char source_file[256] = { 0 };
15780
15781         generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15782
15783         struct stat sst;
15784
15785         if (stat (source_file, &sst) == -1)
15786         {
15787           log_error ("ERROR: %s: %s", source_file, strerror (errno));
15788
15789           return -1;
15790         }
15791
15792         /**
15793          * kernel amp cached filename
15794          */
15795
15796         char cached_file[256] = { 0 };
15797
15798         generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15799
15800         int cached = 1;
15801
15802         struct stat cst;
15803
15804         if (stat (cached_file, &cst) == -1)
15805         {
15806           cached = 0;
15807         }
15808
15809         /**
15810          * kernel compile or load
15811          */
15812
15813         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15814
15815         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15816
15817         if (cached == 0)
15818         {
15819           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));
15820           if (quiet == 0) log_info ("");
15821
15822           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15823
15824           device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15825
15826           int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15827
15828           if (rc != 0)
15829           {
15830             device_param->skipped = true;
15831
15832             log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15833
15834             continue;
15835           }
15836
15837           size_t binary_size;
15838
15839           hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15840
15841           u8 *binary = (u8 *) mymalloc (binary_size);
15842
15843           hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15844
15845           writeProgramBin (cached_file, binary, binary_size);
15846
15847           local_free (binary);
15848         }
15849         else
15850         {
15851           #ifdef DEBUG
15852           if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15853           #endif
15854
15855           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15856
15857           device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15858
15859           hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15860         }
15861
15862         local_free (kernel_lengths);
15863         local_free (kernel_sources[0]);
15864         local_free (kernel_sources);
15865       }
15866
15867       // some algorithm collide too fast, make that impossible
15868
15869       if (benchmark == 1)
15870       {
15871         ((uint *) digests_buf)[0] = -1;
15872         ((uint *) digests_buf)[1] = -1;
15873         ((uint *) digests_buf)[2] = -1;
15874         ((uint *) digests_buf)[3] = -1;
15875       }
15876
15877       /**
15878        * global buffers
15879        */
15880
15881       device_param->d_pws_buf       = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL);
15882       device_param->d_pws_amp_buf   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL);
15883       device_param->d_tmps          = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_tmps,    NULL);
15884       device_param->d_hooks         = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_hooks,   NULL);
15885       device_param->d_bitmap_s1_a   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15886       device_param->d_bitmap_s1_b   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15887       device_param->d_bitmap_s1_c   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15888       device_param->d_bitmap_s1_d   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15889       device_param->d_bitmap_s2_a   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15890       device_param->d_bitmap_s2_b   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15891       device_param->d_bitmap_s2_c   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15892       device_param->d_bitmap_s2_d   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL);
15893       device_param->d_plain_bufs    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_plains,  NULL);
15894       device_param->d_digests_buf   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_digests, NULL);
15895       device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_shown,   NULL);
15896       device_param->d_salt_bufs     = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_salts,   NULL);
15897       device_param->d_result        = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_results, NULL);
15898       device_param->d_scryptV_buf   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scryptV, NULL);
15899
15900       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);
15901       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);
15902       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);
15903       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);
15904       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);
15905       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);
15906       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);
15907       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);
15908       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf,    CL_TRUE, 0, size_digests, data.digests_buf,   0, NULL, NULL);
15909       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown,  CL_TRUE, 0, size_shown,   data.digests_shown, 0, NULL, NULL);
15910       hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs,      CL_TRUE, 0, size_salts,   data.salts_buf,     0, NULL, NULL);
15911
15912       /**
15913        * special buffers
15914        */
15915
15916       if (attack_kern == ATTACK_KERN_STRAIGHT)
15917       {
15918         device_param->d_rules   = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules,   NULL);
15919         device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15920
15921         hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15922       }
15923       else if (attack_kern == ATTACK_KERN_COMBI)
15924       {
15925         device_param->d_combs           = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL);
15926         device_param->d_combs_c         = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL);
15927         device_param->d_root_css_buf    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL);
15928         device_param->d_markov_css_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15929       }
15930       else if (attack_kern == ATTACK_KERN_BF)
15931       {
15932         device_param->d_bfs             = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL);
15933         device_param->d_bfs_c           = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL);
15934         device_param->d_tm_c            = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm,         NULL);
15935         device_param->d_root_css_buf    = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL);
15936         device_param->d_markov_css_buf  = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15937       }
15938
15939       if (size_esalts)
15940       {
15941         device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15942
15943         hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15944       }
15945
15946       /**
15947        * main host data
15948        */
15949
15950       pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15951
15952       device_param->pws_buf = pws_buf;
15953
15954       comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15955
15956       device_param->combs_buf = combs_buf;
15957
15958       void *hooks_buf = mymalloc (size_hooks);
15959
15960       device_param->hooks_buf = hooks_buf;
15961
15962       /**
15963        * kernel args
15964        */
15965
15966       device_param->kernel_params_buf32[21] = bitmap_mask;
15967       device_param->kernel_params_buf32[22] = bitmap_shift1;
15968       device_param->kernel_params_buf32[23] = bitmap_shift2;
15969       device_param->kernel_params_buf32[24] = 0; // salt_pos
15970       device_param->kernel_params_buf32[25] = 0; // loop_pos
15971       device_param->kernel_params_buf32[26] = 0; // loop_cnt
15972       device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15973       device_param->kernel_params_buf32[28] = 0; // digests_cnt
15974       device_param->kernel_params_buf32[29] = 0; // digests_offset
15975       device_param->kernel_params_buf32[30] = 0; // combs_mode
15976       device_param->kernel_params_buf32[31] = 0; // gid_max
15977
15978       device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15979                                       ? &device_param->d_pws_buf
15980                                       : &device_param->d_pws_amp_buf;
15981       device_param->kernel_params[ 1] = &device_param->d_rules_c;
15982       device_param->kernel_params[ 2] = &device_param->d_combs_c;
15983       device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15984       device_param->kernel_params[ 4] = &device_param->d_tmps;
15985       device_param->kernel_params[ 5] = &device_param->d_hooks;
15986       device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15987       device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15988       device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15989       device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15990       device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15991       device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15992       device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15993       device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15994       device_param->kernel_params[14] = &device_param->d_plain_bufs;
15995       device_param->kernel_params[15] = &device_param->d_digests_buf;
15996       device_param->kernel_params[16] = &device_param->d_digests_shown;
15997       device_param->kernel_params[17] = &device_param->d_salt_bufs;
15998       device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15999       device_param->kernel_params[19] = &device_param->d_result;
16000       device_param->kernel_params[20] = &device_param->d_scryptV_buf;
16001       device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
16002       device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
16003       device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
16004       device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16005       device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16006       device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16007       device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16008       device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16009       device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16010       device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16011       device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16012
16013       device_param->kernel_params_mp_buf64[3] = 0;
16014       device_param->kernel_params_mp_buf32[4] = 0;
16015       device_param->kernel_params_mp_buf32[5] = 0;
16016       device_param->kernel_params_mp_buf32[6] = 0;
16017       device_param->kernel_params_mp_buf32[7] = 0;
16018       device_param->kernel_params_mp_buf32[8] = 0;
16019
16020       device_param->kernel_params_mp[0] = NULL;
16021       device_param->kernel_params_mp[1] = NULL;
16022       device_param->kernel_params_mp[2] = NULL;
16023       device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16024       device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16025       device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16026       device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16027       device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16028       device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16029
16030       device_param->kernel_params_mp_l_buf64[3] = 0;
16031       device_param->kernel_params_mp_l_buf32[4] = 0;
16032       device_param->kernel_params_mp_l_buf32[5] = 0;
16033       device_param->kernel_params_mp_l_buf32[6] = 0;
16034       device_param->kernel_params_mp_l_buf32[7] = 0;
16035       device_param->kernel_params_mp_l_buf32[8] = 0;
16036       device_param->kernel_params_mp_l_buf32[9] = 0;
16037
16038       device_param->kernel_params_mp_l[0] = NULL;
16039       device_param->kernel_params_mp_l[1] = NULL;
16040       device_param->kernel_params_mp_l[2] = NULL;
16041       device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16042       device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16043       device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16044       device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16045       device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16046       device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16047       device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16048
16049       device_param->kernel_params_mp_r_buf64[3] = 0;
16050       device_param->kernel_params_mp_r_buf32[4] = 0;
16051       device_param->kernel_params_mp_r_buf32[5] = 0;
16052       device_param->kernel_params_mp_r_buf32[6] = 0;
16053       device_param->kernel_params_mp_r_buf32[7] = 0;
16054       device_param->kernel_params_mp_r_buf32[8] = 0;
16055
16056       device_param->kernel_params_mp_r[0] = NULL;
16057       device_param->kernel_params_mp_r[1] = NULL;
16058       device_param->kernel_params_mp_r[2] = NULL;
16059       device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16060       device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16061       device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16062       device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16063       device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16064       device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16065
16066       device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16067       device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16068
16069       device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16070       device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16071       device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16072       device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16073       device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16074       device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16075       device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16076
16077       device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16078       device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16079
16080       device_param->kernel_params_memset_buf32[1] = 0; // value
16081       device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16082
16083       device_param->kernel_params_memset[0] = NULL;
16084       device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16085       device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16086
16087       /**
16088        * kernel name
16089        */
16090
16091       size_t kernel_wgs_tmp;
16092
16093       char kernel_name[64] = { 0 };
16094
16095       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16096       {
16097         if (opti_type & OPTI_TYPE_SINGLE_HASH)
16098         {
16099           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16100
16101           device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16102
16103           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16104
16105           device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16106
16107           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16108
16109           device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16110         }
16111         else
16112         {
16113           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16114
16115           device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16116
16117           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16118
16119           device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16120
16121           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16122
16123           device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16124         }
16125
16126         if (data.attack_mode == ATTACK_MODE_BF)
16127         {
16128           if (opts_type & OPTS_TYPE_PT_BITSLICE)
16129           {
16130             snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16131
16132             device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16133
16134             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);
16135           }
16136         }
16137       }
16138       else
16139       {
16140         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16141
16142         device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16143
16144         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16145
16146         device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16147
16148         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16149
16150         device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16151
16152         if (opts_type & OPTS_TYPE_HOOK12)
16153         {
16154           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16155
16156           device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16157
16158           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);
16159         }
16160
16161         if (opts_type & OPTS_TYPE_HOOK23)
16162         {
16163           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16164
16165           device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16166
16167           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);
16168         }
16169       }
16170
16171       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);
16172       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);
16173       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);
16174
16175       for (uint i = 0; i <= 20; i++)
16176       {
16177         hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16178         hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16179         hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16180
16181         if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16182         if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16183       }
16184
16185       for (uint i = 21; i <= 31; i++)
16186       {
16187         hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16188         hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16189         hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16190
16191         if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16192         if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16193       }
16194
16195       // GPU memset
16196
16197       device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16198
16199       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);
16200
16201       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem),  device_param->kernel_params_memset[0]);
16202       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16203       hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16204
16205       // MP start
16206
16207       if (attack_mode == ATTACK_MODE_BF)
16208       {
16209         device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16210         device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16211
16212         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);
16213         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);
16214
16215         if (opts_type & OPTS_TYPE_PT_BITSLICE)
16216         {
16217           hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16218           hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16219         }
16220       }
16221       else if (attack_mode == ATTACK_MODE_HYBRID1)
16222       {
16223         device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16224
16225         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);
16226       }
16227       else if (attack_mode == ATTACK_MODE_HYBRID2)
16228       {
16229         device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16230
16231         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);
16232       }
16233
16234       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16235       {
16236         // nothing to do
16237       }
16238       else
16239       {
16240         device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16241
16242         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);
16243       }
16244
16245       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16246       {
16247         // nothing to do
16248       }
16249       else
16250       {
16251         for (uint i = 0; i < 5; i++)
16252         {
16253           hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16254         }
16255
16256         for (uint i = 5; i < 7; i++)
16257         {
16258           hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16259         }
16260       }
16261
16262       // maybe this has been updated by clGetKernelWorkGroupInfo()
16263       // value can only be decreased, so we don't need to reallocate buffers
16264
16265       device_param->kernel_threads = kernel_threads;
16266
16267       // zero some data buffers
16268
16269       run_kernel_bzero (device_param, device_param->d_pws_buf,        size_pws);
16270       run_kernel_bzero (device_param, device_param->d_pws_amp_buf,    size_pws);
16271       run_kernel_bzero (device_param, device_param->d_tmps,           size_tmps);
16272       run_kernel_bzero (device_param, device_param->d_hooks,          size_hooks);
16273       run_kernel_bzero (device_param, device_param->d_plain_bufs,     size_plains);
16274       run_kernel_bzero (device_param, device_param->d_result,         size_results);
16275
16276       /**
16277        * special buffers
16278        */
16279
16280       if (attack_kern == ATTACK_KERN_STRAIGHT)
16281       {
16282         run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16283       }
16284       else if (attack_kern == ATTACK_KERN_COMBI)
16285       {
16286         run_kernel_bzero (device_param, device_param->d_combs,          size_combs);
16287         run_kernel_bzero (device_param, device_param->d_combs_c,        size_combs);
16288         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
16289         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16290       }
16291       else if (attack_kern == ATTACK_KERN_BF)
16292       {
16293         run_kernel_bzero (device_param, device_param->d_bfs,            size_bfs);
16294         run_kernel_bzero (device_param, device_param->d_bfs_c,          size_bfs);
16295         run_kernel_bzero (device_param, device_param->d_tm_c,           size_tm);
16296         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
16297         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16298       }
16299
16300       #if defined(HAVE_HWMON)
16301
16302       /**
16303        * Store initial fanspeed if gpu_temp_retain is enabled
16304        */
16305
16306       if (gpu_temp_disable == 0)
16307       {
16308         if (gpu_temp_retain != 0)
16309         {
16310           hc_thread_mutex_lock (mux_adl);
16311
16312           if (data.hm_device[device_id].fan_get_supported == 1)
16313           {
16314             const int fanspeed  = hm_get_fanspeed_with_device_id  (device_id);
16315             const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16316
16317             temp_retain_fanspeed_value[device_id]  = fanspeed;
16318             temp_retain_fanpolicy_value[device_id] = fanpolicy;
16319
16320             // we also set it to tell the OS we take control over the fan and it's automatic controller
16321             // if it was set to automatic. we do not control user-defined fanspeeds.
16322
16323             if (fanpolicy == 1)
16324             {
16325               data.hm_device[device_id].fan_set_supported = 1;
16326
16327               int rc = -1;
16328
16329               if (device_param->device_vendor_id == VENDOR_ID_AMD)
16330               {
16331                 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16332               }
16333               else if (device_param->device_vendor_id == VENDOR_ID_NV)
16334               {
16335                 #ifdef LINUX
16336                 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16337                 #endif
16338
16339                 #ifdef WIN
16340                 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16341                 #endif
16342               }
16343
16344               if (rc == 0)
16345               {
16346                 data.hm_device[device_id].fan_set_supported = 1;
16347               }
16348               else
16349               {
16350                 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16351
16352                 data.hm_device[device_id].fan_set_supported = 0;
16353               }
16354             }
16355             else
16356             {
16357               data.hm_device[device_id].fan_set_supported = 0;
16358             }
16359           }
16360
16361           hc_thread_mutex_unlock (mux_adl);
16362         }
16363       }
16364
16365       #endif // HAVE_HWMON
16366     }
16367
16368     if (data.quiet == 0) log_info_nn ("");
16369
16370     /**
16371      * In benchmark-mode, inform user which algorithm is checked
16372      */
16373
16374     if (benchmark == 1)
16375     {
16376       if (machine_readable == 0)
16377       {
16378         quiet = 0;
16379
16380         data.quiet = quiet;
16381
16382         char *hash_type = strhashtype (data.hash_mode); // not a bug
16383
16384         log_info ("Hashtype: %s", hash_type);
16385         log_info ("");
16386       }
16387     }
16388
16389     /**
16390      * keep track of the progress
16391      */
16392
16393     data.words_progress_done     = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16394     data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16395     data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16396
16397     /**
16398      * open filehandles
16399      */
16400
16401     #if _WIN
16402     if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16403     {
16404       log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16405
16406       return (-1);
16407     }
16408
16409     if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16410     {
16411       log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16412
16413       return (-1);
16414     }
16415
16416     if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16417     {
16418       log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16419
16420       return (-1);
16421     }
16422     #endif
16423
16424     /**
16425      * dictionary pad
16426      */
16427
16428     segment_size *= (1024 * 1024);
16429
16430     data.segment_size = segment_size;
16431
16432     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16433
16434     wl_data->buf   = (char *) mymalloc (segment_size);
16435     wl_data->avail = segment_size;
16436     wl_data->incr  = segment_size;
16437     wl_data->cnt   = 0;
16438     wl_data->pos   = 0;
16439
16440     cs_t  *css_buf   = NULL;
16441     uint   css_cnt   = 0;
16442     uint   dictcnt   = 0;
16443     uint   maskcnt   = 1;
16444     char **masks     = NULL;
16445     char **dictfiles = NULL;
16446
16447     uint   mask_from_file = 0;
16448
16449     if (attack_mode == ATTACK_MODE_STRAIGHT)
16450     {
16451       if (wordlist_mode == WL_MODE_FILE)
16452       {
16453         int wls_left = myargc - (optind + 1);
16454
16455         for (int i = 0; i < wls_left; i++)
16456         {
16457           char *l0_filename = myargv[optind + 1 + i];
16458
16459           struct stat l0_stat;
16460
16461           if (stat (l0_filename, &l0_stat) == -1)
16462           {
16463             log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16464
16465             return (-1);
16466           }
16467
16468           uint is_dir = S_ISDIR (l0_stat.st_mode);
16469
16470           if (is_dir == 0)
16471           {
16472             dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16473
16474             dictcnt++;
16475
16476             dictfiles[dictcnt - 1] = l0_filename;
16477           }
16478           else
16479           {
16480             // do not allow --keyspace w/ a directory
16481
16482             if (keyspace == 1)
16483             {
16484               log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16485
16486               return (-1);
16487             }
16488
16489             char **dictionary_files = NULL;
16490
16491             dictionary_files = scan_directory (l0_filename);
16492
16493             if (dictionary_files != NULL)
16494             {
16495               qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16496
16497               for (int d = 0; dictionary_files[d] != NULL; d++)
16498               {
16499                 char *l1_filename = dictionary_files[d];
16500
16501                 struct stat l1_stat;
16502
16503                 if (stat (l1_filename, &l1_stat) == -1)
16504                 {
16505                   log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16506
16507                   return (-1);
16508                 }
16509
16510                 if (S_ISREG (l1_stat.st_mode))
16511                 {
16512                   dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16513
16514                   dictcnt++;
16515
16516                   dictfiles[dictcnt - 1] = strdup (l1_filename);
16517                 }
16518               }
16519             }
16520
16521             local_free (dictionary_files);
16522           }
16523         }
16524
16525         if (dictcnt < 1)
16526         {
16527           log_error ("ERROR: No usable dictionary file found.");
16528
16529           return (-1);
16530         }
16531       }
16532       else if (wordlist_mode == WL_MODE_STDIN)
16533       {
16534         dictcnt = 1;
16535       }
16536     }
16537     else if (attack_mode == ATTACK_MODE_COMBI)
16538     {
16539       // display
16540
16541       char *dictfile1 = myargv[optind + 1 + 0];
16542       char *dictfile2 = myargv[optind + 1 + 1];
16543
16544       // find the bigger dictionary and use as base
16545
16546       FILE *fp1 = NULL;
16547       FILE *fp2 = NULL;
16548
16549       struct stat tmp_stat;
16550
16551       if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16552       {
16553         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16554
16555         return (-1);
16556       }
16557
16558       if (stat (dictfile1, &tmp_stat) == -1)
16559       {
16560         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16561
16562         fclose (fp1);
16563
16564         return (-1);
16565       }
16566
16567       if (S_ISDIR (tmp_stat.st_mode))
16568       {
16569         log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16570
16571         fclose (fp1);
16572
16573         return (-1);
16574       }
16575
16576       if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16577       {
16578         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16579
16580         fclose (fp1);
16581
16582         return (-1);
16583       }
16584
16585       if (stat (dictfile2, &tmp_stat) == -1)
16586       {
16587         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16588
16589         fclose (fp1);
16590         fclose (fp2);
16591
16592         return (-1);
16593       }
16594
16595       if (S_ISDIR (tmp_stat.st_mode))
16596       {
16597         log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16598
16599         fclose (fp1);
16600         fclose (fp2);
16601
16602         return (-1);
16603       }
16604
16605       data.combs_cnt = 1;
16606
16607       data.quiet = 1;
16608
16609       const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16610
16611       data.quiet = quiet;
16612
16613       if (words1_cnt == 0)
16614       {
16615         log_error ("ERROR: %s: empty file", dictfile1);
16616
16617         fclose (fp1);
16618         fclose (fp2);
16619
16620         return (-1);
16621       }
16622
16623       data.combs_cnt = 1;
16624
16625       data.quiet = 1;
16626
16627       const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16628
16629       data.quiet = quiet;
16630
16631       if (words2_cnt == 0)
16632       {
16633         log_error ("ERROR: %s: empty file", dictfile2);
16634
16635         fclose (fp1);
16636         fclose (fp2);
16637
16638         return (-1);
16639       }
16640
16641       fclose (fp1);
16642       fclose (fp2);
16643
16644       data.dictfile  = dictfile1;
16645       data.dictfile2 = dictfile2;
16646
16647       if (words1_cnt >= words2_cnt)
16648       {
16649         data.combs_cnt  = words2_cnt;
16650         data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16651
16652         dictfiles = &data.dictfile;
16653
16654         dictcnt = 1;
16655       }
16656       else
16657       {
16658         data.combs_cnt  = words1_cnt;
16659         data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16660
16661         dictfiles = &data.dictfile2;
16662
16663         dictcnt = 1;
16664
16665         // we also have to switch wordlist related rules!
16666
16667         char *tmpc = data.rule_buf_l;
16668
16669         data.rule_buf_l = data.rule_buf_r;
16670         data.rule_buf_r = tmpc;
16671
16672         int   tmpi = data.rule_len_l;
16673
16674         data.rule_len_l = data.rule_len_r;
16675         data.rule_len_r = tmpi;
16676       }
16677     }
16678     else if (attack_mode == ATTACK_MODE_BF)
16679     {
16680       char *mask = NULL;
16681
16682       maskcnt = 0;
16683
16684       if (benchmark == 0)
16685       {
16686         mask = myargv[optind + 1];
16687
16688         masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16689
16690         if ((optind + 2) <= myargc)
16691         {
16692           struct stat file_stat;
16693
16694           if (stat (mask, &file_stat) == -1)
16695           {
16696             maskcnt = 1;
16697
16698             masks[maskcnt - 1] = mystrdup (mask);
16699           }
16700           else
16701           {
16702             int wls_left = myargc - (optind + 1);
16703
16704             uint masks_avail = INCR_MASKS;
16705
16706             for (int i = 0; i < wls_left; i++)
16707             {
16708               if (i != 0)
16709               {
16710                 mask = myargv[optind + 1 + i];
16711
16712                 if (stat (mask, &file_stat) == -1)
16713                 {
16714                   log_error ("ERROR: %s: %s", mask, strerror (errno));
16715
16716                   return (-1);
16717                 }
16718               }
16719
16720               uint is_file = S_ISREG (file_stat.st_mode);
16721
16722               if (is_file == 1)
16723               {
16724                 FILE *mask_fp;
16725
16726                 if ((mask_fp = fopen (mask, "r")) == NULL)
16727                 {
16728                   log_error ("ERROR: %s: %s", mask, strerror (errno));
16729
16730                   return (-1);
16731                 }
16732
16733                 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16734
16735                 while (!feof (mask_fp))
16736                 {
16737                   memset (line_buf, 0, HCBUFSIZ);
16738
16739                   int line_len = fgetl (mask_fp, line_buf);
16740
16741                   if (line_len == 0) continue;
16742
16743                   if (line_buf[0] == '#') continue;
16744
16745                   if (masks_avail == maskcnt)
16746                   {
16747                     masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16748
16749                     masks_avail += INCR_MASKS;
16750                   }
16751
16752                   masks[maskcnt] = mystrdup (line_buf);
16753
16754                   maskcnt++;
16755                 }
16756
16757                 myfree (line_buf);
16758
16759                 fclose (mask_fp);
16760               }
16761               else
16762               {
16763                 log_error ("ERROR: %s: unsupported file-type", mask);
16764
16765                 return (-1);
16766               }
16767             }
16768
16769             mask_from_file = 1;
16770           }
16771         }
16772         else
16773         {
16774           custom_charset_1 = (char *) "?l?d?u";
16775           custom_charset_2 = (char *) "?l?d";
16776           custom_charset_3 = (char *) "?l?d*!$@_";
16777
16778           mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16779           mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16780           mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16781
16782           masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16783
16784           wordlist_mode = WL_MODE_MASK;
16785
16786           data.wordlist_mode = wordlist_mode;
16787
16788           increment = 1;
16789
16790           maskcnt   = 1;
16791         }
16792       }
16793       else
16794       {
16795         /**
16796          * generate full masks and charsets
16797          */
16798
16799         masks = (char **) mymalloc (sizeof (char *));
16800
16801         switch (hash_mode)
16802         {
16803           case  1731: pw_min = 5;
16804                       pw_max = 5;
16805                       mask = mystrdup ("?b?b?b?b?b");
16806                       break;
16807           case 12500: pw_min = 5;
16808                       pw_max = 5;
16809                       mask = mystrdup ("?b?b?b?b?b");
16810                       break;
16811           default:    pw_min = 7;
16812                       pw_max = 7;
16813                       mask = mystrdup ("?b?b?b?b?b?b?b");
16814                       break;
16815         }
16816
16817         maskcnt = 1;
16818
16819         masks[maskcnt - 1] = mystrdup (mask);
16820
16821         wordlist_mode = WL_MODE_MASK;
16822
16823         data.wordlist_mode = wordlist_mode;
16824
16825         increment = 1;
16826       }
16827
16828       dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16829
16830       if (increment)
16831       {
16832         if (increment_min > pw_min) pw_min = increment_min;
16833
16834         if (increment_max < pw_max) pw_max = increment_max;
16835       }
16836     }
16837     else if (attack_mode == ATTACK_MODE_HYBRID1)
16838     {
16839       data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16840
16841       // display
16842
16843       char *mask = myargv[myargc - 1];
16844
16845       maskcnt = 0;
16846
16847       masks = (char **) mymalloc (1 * sizeof (char *));
16848
16849       // mod
16850
16851       struct stat file_stat;
16852
16853       if (stat (mask, &file_stat) == -1)
16854       {
16855         maskcnt = 1;
16856
16857         masks[maskcnt - 1] = mystrdup (mask);
16858       }
16859       else
16860       {
16861         uint is_file = S_ISREG (file_stat.st_mode);
16862
16863         if (is_file == 1)
16864         {
16865           FILE *mask_fp;
16866
16867           if ((mask_fp = fopen (mask, "r")) == NULL)
16868           {
16869             log_error ("ERROR: %s: %s", mask, strerror (errno));
16870
16871             return (-1);
16872           }
16873
16874           char *line_buf = (char *) mymalloc (HCBUFSIZ);
16875
16876           uint masks_avail = 1;
16877
16878           while (!feof (mask_fp))
16879           {
16880             memset (line_buf, 0, HCBUFSIZ);
16881
16882             int line_len = fgetl (mask_fp, line_buf);
16883
16884             if (line_len == 0) continue;
16885
16886             if (line_buf[0] == '#') continue;
16887
16888             if (masks_avail == maskcnt)
16889             {
16890               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16891
16892               masks_avail += INCR_MASKS;
16893             }
16894
16895             masks[maskcnt] = mystrdup (line_buf);
16896
16897             maskcnt++;
16898           }
16899
16900           myfree (line_buf);
16901
16902           fclose (mask_fp);
16903
16904           mask_from_file = 1;
16905         }
16906         else
16907         {
16908           maskcnt = 1;
16909
16910           masks[maskcnt - 1] = mystrdup (mask);
16911         }
16912       }
16913
16914       // base
16915
16916       int wls_left = myargc - (optind + 2);
16917
16918       for (int i = 0; i < wls_left; i++)
16919       {
16920         char *filename = myargv[optind + 1 + i];
16921
16922         struct stat file_stat;
16923
16924         if (stat (filename, &file_stat) == -1)
16925         {
16926           log_error ("ERROR: %s: %s", filename, strerror (errno));
16927
16928           return (-1);
16929         }
16930
16931         uint is_dir = S_ISDIR (file_stat.st_mode);
16932
16933         if (is_dir == 0)
16934         {
16935           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16936
16937           dictcnt++;
16938
16939           dictfiles[dictcnt - 1] = filename;
16940         }
16941         else
16942         {
16943           // do not allow --keyspace w/ a directory
16944
16945           if (keyspace == 1)
16946           {
16947             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16948
16949             return (-1);
16950           }
16951
16952           char **dictionary_files = NULL;
16953
16954           dictionary_files = scan_directory (filename);
16955
16956           if (dictionary_files != NULL)
16957           {
16958             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16959
16960             for (int d = 0; dictionary_files[d] != NULL; d++)
16961             {
16962               char *l1_filename = dictionary_files[d];
16963
16964               struct stat l1_stat;
16965
16966               if (stat (l1_filename, &l1_stat) == -1)
16967               {
16968                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16969
16970                 return (-1);
16971               }
16972
16973               if (S_ISREG (l1_stat.st_mode))
16974               {
16975                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16976
16977                 dictcnt++;
16978
16979                 dictfiles[dictcnt - 1] = strdup (l1_filename);
16980               }
16981             }
16982           }
16983
16984           local_free (dictionary_files);
16985         }
16986       }
16987
16988       if (dictcnt < 1)
16989       {
16990         log_error ("ERROR: No usable dictionary file found.");
16991
16992         return (-1);
16993       }
16994
16995       if (increment)
16996       {
16997         maskcnt = 0;
16998
16999         uint mask_min = increment_min; // we can't reject smaller masks here
17000         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17001
17002         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17003         {
17004           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17005
17006           if (cur_mask == NULL) break;
17007
17008           masks[maskcnt] = cur_mask;
17009
17010           maskcnt++;
17011
17012           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17013         }
17014       }
17015     }
17016     else if (attack_mode == ATTACK_MODE_HYBRID2)
17017     {
17018       data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17019
17020       // display
17021
17022       char *mask = myargv[optind + 1 + 0];
17023
17024       maskcnt = 0;
17025
17026       masks = (char **) mymalloc (1 * sizeof (char *));
17027
17028       // mod
17029
17030       struct stat file_stat;
17031
17032       if (stat (mask, &file_stat) == -1)
17033       {
17034         maskcnt = 1;
17035
17036         masks[maskcnt - 1] = mystrdup (mask);
17037       }
17038       else
17039       {
17040         uint is_file = S_ISREG (file_stat.st_mode);
17041
17042         if (is_file == 1)
17043         {
17044           FILE *mask_fp;
17045
17046           if ((mask_fp = fopen (mask, "r")) == NULL)
17047           {
17048             log_error ("ERROR: %s: %s", mask, strerror (errno));
17049
17050             return (-1);
17051           }
17052
17053           char *line_buf = (char *) mymalloc (HCBUFSIZ);
17054
17055           uint masks_avail = 1;
17056
17057           while (!feof (mask_fp))
17058           {
17059             memset (line_buf, 0, HCBUFSIZ);
17060
17061             int line_len = fgetl (mask_fp, line_buf);
17062
17063             if (line_len == 0) continue;
17064
17065             if (line_buf[0] == '#') continue;
17066
17067             if (masks_avail == maskcnt)
17068             {
17069               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17070
17071               masks_avail += INCR_MASKS;
17072             }
17073
17074             masks[maskcnt] = mystrdup (line_buf);
17075
17076             maskcnt++;
17077           }
17078
17079           myfree (line_buf);
17080
17081           fclose (mask_fp);
17082
17083           mask_from_file = 1;
17084         }
17085         else
17086         {
17087           maskcnt = 1;
17088
17089           masks[maskcnt - 1] = mystrdup (mask);
17090         }
17091       }
17092
17093       // base
17094
17095       int wls_left = myargc - (optind + 2);
17096
17097       for (int i = 0; i < wls_left; i++)
17098       {
17099         char *filename = myargv[optind + 2 + i];
17100
17101         struct stat file_stat;
17102
17103         if (stat (filename, &file_stat) == -1)
17104         {
17105           log_error ("ERROR: %s: %s", filename, strerror (errno));
17106
17107           return (-1);
17108         }
17109
17110         uint is_dir = S_ISDIR (file_stat.st_mode);
17111
17112         if (is_dir == 0)
17113         {
17114           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17115
17116           dictcnt++;
17117
17118           dictfiles[dictcnt - 1] = filename;
17119         }
17120         else
17121         {
17122           // do not allow --keyspace w/ a directory
17123
17124           if (keyspace == 1)
17125           {
17126             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17127
17128             return (-1);
17129           }
17130
17131           char **dictionary_files = NULL;
17132
17133           dictionary_files = scan_directory (filename);
17134
17135           if (dictionary_files != NULL)
17136           {
17137             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17138
17139             for (int d = 0; dictionary_files[d] != NULL; d++)
17140             {
17141               char *l1_filename = dictionary_files[d];
17142
17143               struct stat l1_stat;
17144
17145               if (stat (l1_filename, &l1_stat) == -1)
17146               {
17147                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17148
17149                 return (-1);
17150               }
17151
17152               if (S_ISREG (l1_stat.st_mode))
17153               {
17154                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17155
17156                 dictcnt++;
17157
17158                 dictfiles[dictcnt - 1] = strdup (l1_filename);
17159               }
17160             }
17161           }
17162
17163           local_free (dictionary_files);
17164         }
17165       }
17166
17167       if (dictcnt < 1)
17168       {
17169         log_error ("ERROR: No usable dictionary file found.");
17170
17171         return (-1);
17172       }
17173
17174       if (increment)
17175       {
17176         maskcnt = 0;
17177
17178         uint mask_min = increment_min; // we can't reject smaller masks here
17179         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17180
17181         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17182         {
17183           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17184
17185           if (cur_mask == NULL) break;
17186
17187           masks[maskcnt] = cur_mask;
17188
17189           maskcnt++;
17190
17191           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17192         }
17193       }
17194     }
17195
17196     data.pw_min = pw_min;
17197     data.pw_max = pw_max;
17198
17199     /**
17200      * weak hash check
17201      */
17202
17203     if (weak_hash_threshold >= salts_cnt)
17204     {
17205       hc_device_param_t *device_param = NULL;
17206
17207       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17208       {
17209         device_param = &data.devices_param[device_id];
17210
17211         if (device_param->skipped) continue;
17212
17213         break;
17214       }
17215
17216       if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17217
17218       for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17219       {
17220         weak_hash_check (device_param, salt_pos);
17221       }
17222
17223       // Display hack, guarantee that there is at least one \r before real start
17224
17225       //if (data.quiet == 0) log_info ("");
17226     }
17227
17228     /**
17229      * status and monitor threads
17230      */
17231
17232     if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17233     {
17234       data.devices_status = STATUS_STARTING;
17235     }
17236
17237     uint ni_threads_cnt = 0;
17238
17239     hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17240
17241     if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17242     {
17243       hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17244
17245       ni_threads_cnt++;
17246     }
17247
17248     /**
17249       * Outfile remove
17250       */
17251
17252     if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17253     {
17254       if (outfile_check_timer != 0)
17255       {
17256         if (data.outfile_check_directory != NULL)
17257         {
17258           if ((hash_mode != 5200) &&
17259               !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
17260               !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17261               (hash_mode != 9000))
17262           {
17263             hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17264
17265             ni_threads_cnt++;
17266           }
17267           else
17268           {
17269             outfile_check_timer = 0;
17270           }
17271         }
17272         else
17273         {
17274           outfile_check_timer = 0;
17275         }
17276       }
17277     }
17278
17279     /**
17280      * Inform the user if we got some hashes remove because of the pot file remove feature
17281      */
17282
17283     if (data.quiet == 0)
17284     {
17285       if (potfile_remove_cracks > 0)
17286       {
17287         if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17288         else                            log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17289       }
17290     }
17291
17292     data.outfile_check_timer = outfile_check_timer;
17293
17294     /**
17295      * main loop
17296      */
17297
17298     char **induction_dictionaries = NULL;
17299
17300     int induction_dictionaries_cnt = 0;
17301
17302     hcstat_table_t *root_table_buf   = NULL;
17303     hcstat_table_t *markov_table_buf = NULL;
17304
17305     uint initial_restore_done = 0;
17306
17307     data.maskcnt = maskcnt;
17308
17309     for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17310     {
17311       if (maskpos > rd->maskpos)
17312       {
17313         rd->dictpos = 0;
17314       }
17315
17316       rd->maskpos  = maskpos;
17317       data.maskpos = maskpos;
17318
17319       if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17320       {
17321         char *mask = masks[maskpos];
17322
17323         if (mask_from_file == 1)
17324         {
17325           if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17326
17327           char *str_ptr;
17328           uint  str_pos;
17329
17330           uint mask_offset = 0;
17331
17332           uint separator_cnt;
17333
17334           for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17335           {
17336             str_ptr = strstr (mask + mask_offset, ",");
17337
17338             if (str_ptr == NULL) break;
17339
17340             str_pos = str_ptr - mask;
17341
17342             // escaped separator, i.e. "\,"
17343
17344             if (str_pos > 0)
17345             {
17346               if (mask[str_pos - 1] == '\\')
17347               {
17348                 separator_cnt --;
17349
17350                 mask_offset = str_pos + 1;
17351
17352                 continue;
17353               }
17354             }
17355
17356             // reset the offset
17357
17358             mask_offset = 0;
17359
17360             mask[str_pos] = '\0';
17361
17362             switch (separator_cnt)
17363             {
17364               case 0:
17365                 mp_reset_usr (mp_usr, 0);
17366
17367                 custom_charset_1 = mask;
17368                 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17369                 break;
17370
17371               case 1:
17372                 mp_reset_usr (mp_usr, 1);
17373
17374                 custom_charset_2 = mask;
17375                 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17376                 break;
17377
17378               case 2:
17379                 mp_reset_usr (mp_usr, 2);
17380
17381                 custom_charset_3 = mask;
17382                 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17383                 break;
17384
17385               case 3:
17386                 mp_reset_usr (mp_usr, 3);
17387
17388                 custom_charset_4 = mask;
17389                 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17390                 break;
17391             }
17392
17393             mask = mask + str_pos + 1;
17394           }
17395         }
17396
17397         if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17398         {
17399           if (maskpos > 0)
17400           {
17401             local_free (css_buf);
17402             local_free (data.root_css_buf);
17403             local_free (data.markov_css_buf);
17404
17405             local_free (masks[maskpos - 1]);
17406           }
17407
17408           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17409
17410           data.mask = mask;
17411           data.css_cnt = css_cnt;
17412           data.css_buf = css_buf;
17413
17414           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17415
17416           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17417
17418           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
17419           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17420
17421           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17422
17423           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17424
17425           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
17426           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17427
17428           data.root_css_buf   = root_css_buf;
17429           data.markov_css_buf = markov_css_buf;
17430
17431           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17432
17433           data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17434
17435           local_free (root_table_buf);
17436           local_free (markov_table_buf);
17437
17438           // args
17439
17440           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17441           {
17442             hc_device_param_t *device_param = &data.devices_param[device_id];
17443
17444             if (device_param->skipped) continue;
17445
17446             device_param->kernel_params_mp[0] = &device_param->d_combs;
17447             device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17448             device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17449
17450             device_param->kernel_params_mp_buf64[3] = 0;
17451             device_param->kernel_params_mp_buf32[4] = css_cnt;
17452             device_param->kernel_params_mp_buf32[5] = 0;
17453             device_param->kernel_params_mp_buf32[6] = 0;
17454             device_param->kernel_params_mp_buf32[7] = 0;
17455
17456             if (attack_mode == ATTACK_MODE_HYBRID1)
17457             {
17458               if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_buf32[5] = full01;
17459               if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_buf32[5] = full80;
17460               if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17461               if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17462             }
17463             else if (attack_mode == ATTACK_MODE_HYBRID2)
17464             {
17465               device_param->kernel_params_mp_buf32[5] = 0;
17466               device_param->kernel_params_mp_buf32[6] = 0;
17467               device_param->kernel_params_mp_buf32[7] = 0;
17468             }
17469
17470             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]);
17471             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]);
17472             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]);
17473
17474             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);
17475             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);
17476           }
17477         }
17478         else if (attack_mode == ATTACK_MODE_BF)
17479         {
17480           dictcnt = 0;  // number of "sub-masks", i.e. when using incremental mode
17481
17482           if (increment)
17483           {
17484             for (uint i = 0; i < dictcnt; i++)
17485             {
17486               local_free (dictfiles[i]);
17487             }
17488
17489             for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17490             {
17491               char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17492
17493               if (l1_filename == NULL) break;
17494
17495               dictcnt++;
17496
17497               dictfiles[dictcnt - 1] = l1_filename;
17498             }
17499           }
17500           else
17501           {
17502             dictcnt++;
17503
17504             dictfiles[dictcnt - 1] = mask;
17505           }
17506
17507           if (dictcnt == 0)
17508           {
17509             log_error ("ERROR: Mask is too small");
17510
17511             return (-1);
17512           }
17513         }
17514       }
17515
17516       free (induction_dictionaries);
17517
17518       // induction_dictionaries_cnt = 0; // implied
17519
17520       if (attack_mode != ATTACK_MODE_BF)
17521       {
17522         if (keyspace == 0)
17523         {
17524           induction_dictionaries = scan_directory (induction_directory);
17525
17526           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17527         }
17528       }
17529
17530       if (induction_dictionaries_cnt)
17531       {
17532         qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17533       }
17534
17535       /**
17536        * prevent the user from using --keyspace together w/ maskfile and or dictfile
17537        */
17538       if (keyspace == 1)
17539       {
17540         if ((maskcnt > 1) || (dictcnt > 1))
17541         {
17542           log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17543
17544           return (-1);
17545         }
17546       }
17547
17548       for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17549       {
17550         char *subid = logfile_generate_subid ();
17551
17552         data.subid = subid;
17553
17554         logfile_sub_msg ("START");
17555
17556         if (data.devices_status == STATUS_STARTING)
17557         {
17558           data.devices_status = STATUS_INIT;
17559         }
17560
17561         memset (data.words_progress_done,     0, data.salts_cnt * sizeof (u64));
17562         memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17563         memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17564
17565         memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17566
17567         data.cpt_pos = 0;
17568
17569         data.cpt_start = time (NULL);
17570
17571         data.cpt_total = 0;
17572
17573         if (data.restore == 0)
17574         {
17575           rd->words_cur = skip;
17576
17577           skip = 0;
17578
17579           data.skip = 0;
17580         }
17581
17582         data.ms_paused = 0;
17583
17584         data.kernel_power_final = 0;
17585
17586         data.words_cur = rd->words_cur;
17587
17588         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17589         {
17590           hc_device_param_t *device_param = &data.devices_param[device_id];
17591
17592           if (device_param->skipped) continue;
17593
17594           device_param->speed_pos = 0;
17595
17596           memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17597           memset (device_param->speed_ms,  0, SPEED_CACHE * sizeof (double));
17598
17599           device_param->exec_pos = 0;
17600
17601           memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17602
17603           device_param->outerloop_pos  = 0;
17604           device_param->outerloop_left = 0;
17605           device_param->innerloop_pos  = 0;
17606           device_param->innerloop_left = 0;
17607
17608           // some more resets:
17609
17610           if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17611
17612           device_param->pws_cnt = 0;
17613
17614           device_param->words_off  = 0;
17615           device_param->words_done = 0;
17616         }
17617
17618         // figure out some workload
17619
17620         if (attack_mode == ATTACK_MODE_STRAIGHT)
17621         {
17622           if (data.wordlist_mode == WL_MODE_FILE)
17623           {
17624             char *dictfile = NULL;
17625
17626             if (induction_dictionaries_cnt)
17627             {
17628               dictfile = induction_dictionaries[0];
17629             }
17630             else
17631             {
17632               dictfile = dictfiles[dictpos];
17633             }
17634
17635             data.dictfile = dictfile;
17636
17637             logfile_sub_string (dictfile);
17638
17639             for (uint i = 0; i < rp_files_cnt; i++)
17640             {
17641               logfile_sub_var_string ("rulefile", rp_files[i]);
17642             }
17643
17644             FILE *fd2 = fopen (dictfile, "rb");
17645
17646             if (fd2 == NULL)
17647             {
17648               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17649
17650               return (-1);
17651             }
17652
17653             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17654
17655             fclose (fd2);
17656
17657             if (data.words_cnt == 0)
17658             {
17659               dictpos++;
17660
17661               continue;
17662             }
17663           }
17664         }
17665         else if (attack_mode == ATTACK_MODE_COMBI)
17666         {
17667           char *dictfile  = data.dictfile;
17668           char *dictfile2 = data.dictfile2;
17669
17670           logfile_sub_string (dictfile);
17671           logfile_sub_string (dictfile2);
17672
17673           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17674           {
17675             FILE *fd2 = fopen (dictfile, "rb");
17676
17677             if (fd2 == NULL)
17678             {
17679               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17680
17681               return (-1);
17682             }
17683
17684             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17685
17686             fclose (fd2);
17687           }
17688           else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17689           {
17690             FILE *fd2 = fopen (dictfile2, "rb");
17691
17692             if (fd2 == NULL)
17693             {
17694               log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17695
17696               return (-1);
17697             }
17698
17699             data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17700
17701             fclose (fd2);
17702           }
17703
17704           if (data.words_cnt == 0)
17705           {
17706             dictpos++;
17707
17708             continue;
17709           }
17710         }
17711         else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17712         {
17713           char *dictfile = NULL;
17714
17715           if (induction_dictionaries_cnt)
17716           {
17717             dictfile = induction_dictionaries[0];
17718           }
17719           else
17720           {
17721             dictfile = dictfiles[dictpos];
17722           }
17723
17724           data.dictfile = dictfile;
17725
17726           char *mask = data.mask;
17727
17728           logfile_sub_string (dictfile);
17729           logfile_sub_string (mask);
17730
17731           FILE *fd2 = fopen (dictfile, "rb");
17732
17733           if (fd2 == NULL)
17734           {
17735             log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17736
17737             return (-1);
17738           }
17739
17740           data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17741
17742           fclose (fd2);
17743
17744           if (data.words_cnt == 0)
17745           {
17746             dictpos++;
17747
17748             continue;
17749           }
17750         }
17751         else if (attack_mode == ATTACK_MODE_BF)
17752         {
17753           local_free (css_buf);
17754           local_free (data.root_css_buf);
17755           local_free (data.markov_css_buf);
17756
17757           char *mask = dictfiles[dictpos];
17758
17759           logfile_sub_string (mask);
17760
17761           // base
17762
17763           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17764
17765           if (opts_type & OPTS_TYPE_PT_UNICODE)
17766           {
17767             uint css_cnt_unicode = css_cnt * 2;
17768
17769             cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17770
17771             for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17772             {
17773               memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17774
17775               css_buf_unicode[j + 1].cs_buf[0] = 0;
17776               css_buf_unicode[j + 1].cs_len    = 1;
17777             }
17778
17779             free (css_buf);
17780
17781             css_buf = css_buf_unicode;
17782             css_cnt = css_cnt_unicode;
17783           }
17784
17785           // check if mask is not too large or too small for pw_min/pw_max  (*2 if unicode)
17786
17787           uint mask_min = pw_min;
17788           uint mask_max = pw_max;
17789
17790           if (opts_type & OPTS_TYPE_PT_UNICODE)
17791           {
17792             mask_min *= 2;
17793             mask_max *= 2;
17794           }
17795
17796           if ((css_cnt < mask_min) || (css_cnt > mask_max))
17797           {
17798             if (css_cnt < mask_min)
17799             {
17800               log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17801             }
17802
17803             if (css_cnt > mask_max)
17804             {
17805               log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17806             }
17807
17808             // skip to next mask
17809
17810             dictpos++;
17811
17812             rd->dictpos = dictpos;
17813
17814             logfile_sub_msg ("STOP");
17815
17816             continue;
17817           }
17818
17819           uint save_css_cnt = css_cnt;
17820
17821           if (opti_type & OPTI_TYPE_SINGLE_HASH)
17822           {
17823             if (opti_type & OPTI_TYPE_APPENDED_SALT)
17824             {
17825               uint  salt_len = (uint)   data.salts_buf[0].salt_len;
17826               char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17827
17828               uint css_cnt_salt = css_cnt + salt_len;
17829
17830               cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17831
17832               memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17833
17834               for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17835               {
17836                 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17837                 css_buf_salt[j].cs_len    = 1;
17838               }
17839
17840               free (css_buf);
17841
17842               css_buf = css_buf_salt;
17843               css_cnt = css_cnt_salt;
17844             }
17845           }
17846
17847           data.mask = mask;
17848           data.css_cnt = css_cnt;
17849           data.css_buf = css_buf;
17850
17851           if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17852
17853           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17854
17855           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17856
17857           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
17858           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17859
17860           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17861
17862           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17863
17864           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
17865           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17866
17867           data.root_css_buf   = root_css_buf;
17868           data.markov_css_buf = markov_css_buf;
17869
17870           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17871
17872           data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17873
17874           local_free (root_table_buf);
17875           local_free (markov_table_buf);
17876
17877           // copy + args
17878
17879           uint css_cnt_l = css_cnt;
17880           uint css_cnt_r;
17881
17882           if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17883           {
17884             if (save_css_cnt < 6)
17885             {
17886               css_cnt_r = 1;
17887             }
17888             else if (save_css_cnt == 6)
17889             {
17890               css_cnt_r = 2;
17891             }
17892             else
17893             {
17894               if (opts_type & OPTS_TYPE_PT_UNICODE)
17895               {
17896                 if (save_css_cnt == 8 || save_css_cnt == 10)
17897                 {
17898                   css_cnt_r = 2;
17899                 }
17900                 else
17901                 {
17902                   css_cnt_r = 4;
17903                 }
17904               }
17905               else
17906               {
17907                 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17908                 {
17909                   css_cnt_r = 3;
17910                 }
17911                 else
17912                 {
17913                   css_cnt_r = 4;
17914                 }
17915               }
17916             }
17917           }
17918           else
17919           {
17920             css_cnt_r = 1;
17921
17922             /* unfinished code?
17923             int sum = css_buf[css_cnt_r - 1].cs_len;
17924
17925             for (uint i = 1; i < 4 && i < css_cnt; i++)
17926             {
17927               if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17928
17929               css_cnt_r++;
17930
17931               sum *= css_buf[css_cnt_r - 1].cs_len;
17932             }
17933             */
17934           }
17935
17936           css_cnt_l -= css_cnt_r;
17937
17938           data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17939
17940           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17941           {
17942             hc_device_param_t *device_param = &data.devices_param[device_id];
17943
17944             if (device_param->skipped) continue;
17945
17946             device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17947             device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17948             device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17949
17950             device_param->kernel_params_mp_l_buf64[3] = 0;
17951             device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17952             device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17953             device_param->kernel_params_mp_l_buf32[6] = 0;
17954             device_param->kernel_params_mp_l_buf32[7] = 0;
17955             device_param->kernel_params_mp_l_buf32[8] = 0;
17956
17957             if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_l_buf32[6] = full01;
17958             if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_l_buf32[6] = full80;
17959             if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17960             if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17961
17962             device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17963             device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17964             device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17965
17966             device_param->kernel_params_mp_r_buf64[3] = 0;
17967             device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17968             device_param->kernel_params_mp_r_buf32[5] = 0;
17969             device_param->kernel_params_mp_r_buf32[6] = 0;
17970             device_param->kernel_params_mp_r_buf32[7] = 0;
17971
17972             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]);
17973             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]);
17974             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]);
17975
17976             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]);
17977             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]);
17978             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]);
17979
17980             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);
17981             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);
17982           }
17983         }
17984
17985         u64 words_base = data.words_cnt;
17986
17987         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17988         {
17989           if (data.kernel_rules_cnt)
17990           {
17991             words_base /= data.kernel_rules_cnt;
17992           }
17993         }
17994         else if (data.attack_kern == ATTACK_KERN_COMBI)
17995         {
17996           if (data.combs_cnt)
17997           {
17998             words_base /= data.combs_cnt;
17999           }
18000         }
18001         else if (data.attack_kern == ATTACK_KERN_BF)
18002         {
18003           if (data.bfs_cnt)
18004           {
18005             words_base /= data.bfs_cnt;
18006           }
18007         }
18008
18009         data.words_base = words_base;
18010
18011         if (keyspace == 1)
18012         {
18013           log_info ("%llu", (unsigned long long int) words_base);
18014
18015           return (0);
18016         }
18017
18018         if (data.words_cur > data.words_base)
18019         {
18020           log_error ("ERROR: Restore value greater keyspace");
18021
18022           return (-1);
18023         }
18024
18025         if (data.words_cur)
18026         {
18027           if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18028           {
18029             for (uint i = 0; i < data.salts_cnt; i++)
18030             {
18031               data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18032             }
18033           }
18034           else if (data.attack_kern == ATTACK_KERN_COMBI)
18035           {
18036             for (uint i = 0; i < data.salts_cnt; i++)
18037             {
18038               data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18039             }
18040           }
18041           else if (data.attack_kern == ATTACK_KERN_BF)
18042           {
18043             for (uint i = 0; i < data.salts_cnt; i++)
18044             {
18045               data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18046             }
18047           }
18048         }
18049
18050         /*
18051          * Update loopback file
18052          */
18053
18054         if (loopback == 1)
18055         {
18056           time_t now;
18057
18058           time (&now);
18059
18060           uint random_num = get_random_num (0, 9999);
18061
18062           snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18063
18064           data.loopback_file = loopback_file;
18065         }
18066
18067         /*
18068          * Update dictionary statistic
18069          */
18070
18071         if (keyspace == 0)
18072         {
18073           dictstat_fp = fopen (dictstat, "wb");
18074
18075           if (dictstat_fp)
18076           {
18077             lock_file (dictstat_fp);
18078
18079             fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18080
18081             fclose (dictstat_fp);
18082           }
18083         }
18084
18085         /**
18086          * create autotune threads
18087          */
18088
18089         hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18090
18091         if (data.devices_status == STATUS_INIT)
18092         {
18093           data.devices_status = STATUS_AUTOTUNE;
18094
18095           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18096           {
18097             hc_device_param_t *device_param = &devices_param[device_id];
18098
18099             hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18100           }
18101         }
18102
18103         hc_thread_wait (data.devices_cnt, c_threads);
18104
18105         /*
18106          * Inform user about possible slow speeds
18107          */
18108
18109         uint hardware_power_all = 0;
18110
18111         uint kernel_power_all = 0;
18112
18113         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18114         {
18115           hc_device_param_t *device_param = &devices_param[device_id];
18116
18117           hardware_power_all += device_param->hardware_power;
18118
18119           kernel_power_all += device_param->kernel_power;
18120         }
18121
18122         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
18123
18124         data.kernel_power_all = kernel_power_all;
18125
18126         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18127         {
18128           if (data.words_base < kernel_power_all)
18129           {
18130             if (quiet == 0)
18131             {
18132               clear_prompt ();
18133
18134               log_info ("ATTENTION!");
18135               log_info ("  The wordlist or mask you are using is too small.");
18136               log_info ("  Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18137               log_info ("  The cracking speed will drop.");
18138               log_info ("  Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18139               log_info ("");
18140             }
18141           }
18142         }
18143
18144         /**
18145          * create cracker threads
18146          */
18147
18148         if (data.devices_status == STATUS_AUTOTUNE)
18149         {
18150           data.devices_status = STATUS_RUNNING;
18151         }
18152
18153         if (initial_restore_done == 0)
18154         {
18155           if (data.restore_disable == 0) cycle_restore ();
18156
18157           initial_restore_done = 1;
18158         }
18159
18160         hc_timer_set (&data.timer_running);
18161
18162         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18163         {
18164           if ((quiet == 0) && (status == 0) && (benchmark == 0))
18165           {
18166             if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18167             if (quiet == 0) fflush (stdout);
18168           }
18169         }
18170         else if (wordlist_mode == WL_MODE_STDIN)
18171         {
18172           if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18173           if (data.quiet == 0) log_info ("");
18174         }
18175
18176         time_t runtime_start;
18177
18178         time (&runtime_start);
18179
18180         data.runtime_start = runtime_start;
18181
18182         if (data.devices_status == STATUS_RUNNING)
18183         {
18184           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18185           {
18186             hc_device_param_t *device_param = &devices_param[device_id];
18187
18188             if (wordlist_mode == WL_MODE_STDIN)
18189             {
18190               hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18191             }
18192             else
18193             {
18194               hc_thread_create (c_threads[device_id], thread_calc, device_param);
18195             }
18196           }
18197         }
18198
18199         hc_thread_wait (data.devices_cnt, c_threads);
18200
18201         local_free (c_threads);
18202
18203         logfile_sub_var_uint ("status-after-work", data.devices_status);
18204
18205         data.restore = 0;
18206
18207         if (induction_dictionaries_cnt)
18208         {
18209           unlink (induction_dictionaries[0]);
18210         }
18211
18212         free (induction_dictionaries);
18213
18214         if (attack_mode != ATTACK_MODE_BF)
18215         {
18216           induction_dictionaries = scan_directory (induction_directory);
18217
18218           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18219         }
18220
18221         if (benchmark == 0)
18222         {
18223           if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18224           {
18225             if (quiet == 0) clear_prompt ();
18226
18227             if (quiet == 0) log_info ("");
18228
18229             if (status == 1)
18230             {
18231               status_display ();
18232             }
18233             else
18234             {
18235               if (quiet == 0) status_display ();
18236             }
18237
18238             if (quiet == 0) log_info ("");
18239           }
18240         }
18241
18242         if (attack_mode == ATTACK_MODE_BF)
18243         {
18244           dictpos++;
18245
18246           rd->dictpos = dictpos;
18247         }
18248         else
18249         {
18250           if (induction_dictionaries_cnt)
18251           {
18252             qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18253           }
18254           else
18255           {
18256             dictpos++;
18257
18258             rd->dictpos = dictpos;
18259           }
18260         }
18261
18262         time_t runtime_stop;
18263
18264         time (&runtime_stop);
18265
18266         data.runtime_stop = runtime_stop;
18267
18268         logfile_sub_uint (runtime_start);
18269         logfile_sub_uint (runtime_stop);
18270
18271         logfile_sub_msg ("STOP");
18272
18273         global_free (subid);
18274
18275         // finalize task
18276
18277         if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18278
18279         if (data.devices_status == STATUS_CRACKED) break;
18280         if (data.devices_status == STATUS_ABORTED) break;
18281         if (data.devices_status == STATUS_QUIT)    break;
18282
18283         if (data.devices_status == STATUS_BYPASS)
18284         {
18285           data.devices_status = STATUS_RUNNING;
18286         }
18287       }
18288
18289       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18290
18291       if (data.devices_status == STATUS_CRACKED) break;
18292       if (data.devices_status == STATUS_ABORTED) break;
18293       if (data.devices_status == STATUS_QUIT)    break;
18294
18295       if (data.devices_status == STATUS_BYPASS)
18296       {
18297         data.devices_status = STATUS_RUNNING;
18298       }
18299     }
18300
18301     // 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
18302
18303     if (attack_mode == ATTACK_MODE_STRAIGHT)
18304     {
18305       if (data.wordlist_mode == WL_MODE_FILE)
18306       {
18307         if (data.dictfile == NULL)
18308         {
18309           if (dictfiles != NULL)
18310           {
18311             data.dictfile = dictfiles[0];
18312
18313             hc_timer_set (&data.timer_running);
18314           }
18315         }
18316       }
18317     }
18318     // NOTE: combi is okay because it is already set beforehand
18319     else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18320     {
18321       if (data.dictfile == NULL)
18322       {
18323         if (dictfiles != NULL)
18324         {
18325           hc_timer_set (&data.timer_running);
18326
18327           data.dictfile = dictfiles[0];
18328         }
18329       }
18330     }
18331     else if (attack_mode == ATTACK_MODE_BF)
18332     {
18333       if (data.mask == NULL)
18334       {
18335         hc_timer_set (&data.timer_running);
18336
18337         data.mask = masks[0];
18338       }
18339     }
18340
18341     if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18342     {
18343       data.devices_status = STATUS_EXHAUSTED;
18344     }
18345
18346     // if cracked / aborted remove last induction dictionary
18347
18348     for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18349     {
18350       struct stat induct_stat;
18351
18352       if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18353       {
18354         unlink (induction_dictionaries[file_pos]);
18355       }
18356     }
18357
18358     // wait for non-interactive threads
18359
18360     for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18361     {
18362       hc_thread_wait (1, &ni_threads[thread_idx]);
18363     }
18364
18365     local_free (ni_threads);
18366
18367     // we dont need restore file anymore
18368     if (data.restore_disable == 0)
18369     {
18370       if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18371       {
18372         unlink (eff_restore_file);
18373         unlink (new_restore_file);
18374       }
18375       else
18376       {
18377         cycle_restore ();
18378       }
18379     }
18380
18381     // finally save left hashes
18382
18383     if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18384     {
18385       save_hash ();
18386     }
18387
18388     /**
18389      * Clean up
18390      */
18391
18392     if (benchmark == 1)
18393     {
18394       status_benchmark ();
18395
18396       if (machine_readable == 0)
18397       {
18398         log_info ("");
18399       }
18400     }
18401     else
18402     {
18403       if (quiet == 0)
18404       {
18405         clear_prompt ();
18406
18407         log_info ("");
18408
18409         if (stdout_flag == 0) status_display ();
18410
18411         log_info ("");
18412       }
18413     }
18414
18415     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18416     {
18417       hc_device_param_t *device_param = &data.devices_param[device_id];
18418
18419       if (device_param->skipped) continue;
18420
18421       local_free (device_param->combs_buf);
18422
18423       local_free (device_param->hooks_buf);
18424
18425       local_free (device_param->device_name);
18426
18427       local_free (device_param->device_name_chksum);
18428
18429       local_free (device_param->device_version);
18430
18431       local_free (device_param->driver_version);
18432
18433       if (device_param->pws_buf)            myfree                    (device_param->pws_buf);
18434       if (device_param->d_pws_buf)          hc_clReleaseMemObject     (data.ocl, device_param->d_pws_buf);
18435       if (device_param->d_pws_amp_buf)      hc_clReleaseMemObject     (data.ocl, device_param->d_pws_amp_buf);
18436       if (device_param->d_rules)            hc_clReleaseMemObject     (data.ocl, device_param->d_rules);
18437       if (device_param->d_rules_c)          hc_clReleaseMemObject     (data.ocl, device_param->d_rules_c);
18438       if (device_param->d_combs)            hc_clReleaseMemObject     (data.ocl, device_param->d_combs);
18439       if (device_param->d_combs_c)          hc_clReleaseMemObject     (data.ocl, device_param->d_combs_c);
18440       if (device_param->d_bfs)              hc_clReleaseMemObject     (data.ocl, device_param->d_bfs);
18441       if (device_param->d_bfs_c)            hc_clReleaseMemObject     (data.ocl, device_param->d_bfs_c);
18442       if (device_param->d_bitmap_s1_a)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_a);
18443       if (device_param->d_bitmap_s1_b)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_b);
18444       if (device_param->d_bitmap_s1_c)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_c);
18445       if (device_param->d_bitmap_s1_d)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s1_d);
18446       if (device_param->d_bitmap_s2_a)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_a);
18447       if (device_param->d_bitmap_s2_b)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_b);
18448       if (device_param->d_bitmap_s2_c)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_c);
18449       if (device_param->d_bitmap_s2_d)      hc_clReleaseMemObject     (data.ocl, device_param->d_bitmap_s2_d);
18450       if (device_param->d_plain_bufs)       hc_clReleaseMemObject     (data.ocl, device_param->d_plain_bufs);
18451       if (device_param->d_digests_buf)      hc_clReleaseMemObject     (data.ocl, device_param->d_digests_buf);
18452       if (device_param->d_digests_shown)    hc_clReleaseMemObject     (data.ocl, device_param->d_digests_shown);
18453       if (device_param->d_salt_bufs)        hc_clReleaseMemObject     (data.ocl, device_param->d_salt_bufs);
18454       if (device_param->d_esalt_bufs)       hc_clReleaseMemObject     (data.ocl, device_param->d_esalt_bufs);
18455       if (device_param->d_tmps)             hc_clReleaseMemObject     (data.ocl, device_param->d_tmps);
18456       if (device_param->d_hooks)            hc_clReleaseMemObject     (data.ocl, device_param->d_hooks);
18457       if (device_param->d_result)           hc_clReleaseMemObject     (data.ocl, device_param->d_result);
18458       if (device_param->d_scryptV_buf)      hc_clReleaseMemObject     (data.ocl, device_param->d_scryptV_buf);
18459       if (device_param->d_root_css_buf)     hc_clReleaseMemObject     (data.ocl, device_param->d_root_css_buf);
18460       if (device_param->d_markov_css_buf)   hc_clReleaseMemObject     (data.ocl, device_param->d_markov_css_buf);
18461       if (device_param->d_tm_c)             hc_clReleaseMemObject     (data.ocl, device_param->d_tm_c);
18462
18463       if (device_param->kernel1)            hc_clReleaseKernel        (data.ocl, device_param->kernel1);
18464       if (device_param->kernel12)           hc_clReleaseKernel        (data.ocl, device_param->kernel12);
18465       if (device_param->kernel2)            hc_clReleaseKernel        (data.ocl, device_param->kernel2);
18466       if (device_param->kernel23)           hc_clReleaseKernel        (data.ocl, device_param->kernel23);
18467       if (device_param->kernel3)            hc_clReleaseKernel        (data.ocl, device_param->kernel3);
18468       if (device_param->kernel_mp)          hc_clReleaseKernel        (data.ocl, device_param->kernel_mp);
18469       if (device_param->kernel_mp_l)        hc_clReleaseKernel        (data.ocl, device_param->kernel_mp_l);
18470       if (device_param->kernel_mp_r)        hc_clReleaseKernel        (data.ocl, device_param->kernel_mp_r);
18471       if (device_param->kernel_tm)          hc_clReleaseKernel        (data.ocl, device_param->kernel_tm);
18472       if (device_param->kernel_amp)         hc_clReleaseKernel        (data.ocl, device_param->kernel_amp);
18473       if (device_param->kernel_memset)      hc_clReleaseKernel        (data.ocl, device_param->kernel_memset);
18474
18475       if (device_param->program)            hc_clReleaseProgram       (data.ocl, device_param->program);
18476       if (device_param->program_mp)         hc_clReleaseProgram       (data.ocl, device_param->program_mp);
18477       if (device_param->program_amp)        hc_clReleaseProgram       (data.ocl, device_param->program_amp);
18478
18479       if (device_param->command_queue)      hc_clReleaseCommandQueue  (data.ocl, device_param->command_queue);
18480       if (device_param->context)            hc_clReleaseContext       (data.ocl, device_param->context);
18481     }
18482
18483     // reset default fan speed
18484
18485     #ifdef HAVE_HWMON
18486     if (gpu_temp_disable == 0)
18487     {
18488       if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18489       {
18490         hc_thread_mutex_lock (mux_adl);
18491
18492         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18493         {
18494           hc_device_param_t *device_param = &data.devices_param[device_id];
18495
18496           if (device_param->skipped) continue;
18497
18498           if (data.hm_device[device_id].fan_set_supported == 1)
18499           {
18500             int fanspeed  = temp_retain_fanspeed_value[device_id];
18501             int fanpolicy = temp_retain_fanpolicy_value[device_id];
18502
18503             if (fanpolicy == 1)
18504             {
18505               int rc = -1;
18506
18507               if (device_param->device_vendor_id == VENDOR_ID_AMD)
18508               {
18509                 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18510               }
18511               else if (device_param->device_vendor_id == VENDOR_ID_NV)
18512               {
18513                 #ifdef LINUX
18514                 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18515                 #endif
18516
18517                 #ifdef WIN
18518                 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy);
18519                 #endif
18520               }
18521
18522               if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18523             }
18524           }
18525         }
18526
18527         hc_thread_mutex_unlock (mux_adl);
18528       }
18529     }
18530
18531     // reset power tuning
18532
18533     if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18534     {
18535       hc_thread_mutex_lock (mux_adl);
18536
18537       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18538       {
18539         hc_device_param_t *device_param = &data.devices_param[device_id];
18540
18541         if (device_param->skipped) continue;
18542
18543         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18544         {
18545           if (data.hm_device[device_id].od_version == 6)
18546           {
18547             // check powertune capabilities first, if not available then skip device
18548
18549             int powertune_supported = 0;
18550
18551             if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18552             {
18553               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18554
18555               return (-1);
18556             }
18557
18558             if (powertune_supported != 0)
18559             {
18560               // powercontrol settings
18561
18562               if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18563               {
18564                 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18565
18566                 return (-1);
18567               }
18568
18569               // clocks
18570
18571               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18572
18573               performance_state->iNumberOfPerformanceLevels = 2;
18574
18575               performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18576               performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18577               performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18578               performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18579
18580               if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18581               {
18582                 log_info ("ERROR: Failed to restore ADL performance state");
18583
18584                 return (-1);
18585               }
18586
18587               local_free (performance_state);
18588             }
18589           }
18590         }
18591
18592         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18593         {
18594           unsigned int limit = nvml_power_limit[device_id];
18595
18596           if (limit > 0)
18597           {
18598             hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18599           }
18600         }
18601       }
18602
18603       hc_thread_mutex_unlock (mux_adl);
18604     }
18605
18606     if (gpu_temp_disable == 0)
18607     {
18608       if (data.hm_nvml)
18609       {
18610         hm_NVML_nvmlShutdown (data.hm_nvml);
18611
18612         nvml_close (data.hm_nvml);
18613
18614         data.hm_nvml = NULL;
18615       }
18616
18617       if (data.hm_nvapi)
18618       {
18619         hm_NvAPI_Unload (data.hm_nvapi);
18620
18621         nvapi_close (data.hm_nvapi);
18622
18623         data.hm_nvapi = NULL;
18624       }
18625
18626       if (data.hm_xnvctrl)
18627       {
18628         hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18629
18630         xnvctrl_close (data.hm_xnvctrl);
18631
18632         data.hm_xnvctrl = NULL;
18633       }
18634
18635       if (data.hm_adl)
18636       {
18637         hm_ADL_Main_Control_Destroy (data.hm_adl);
18638
18639         adl_close (data.hm_adl);
18640
18641         data.hm_adl = NULL;
18642       }
18643     }
18644     #endif // HAVE_HWMON
18645
18646     // free memory
18647
18648     local_free (masks);
18649
18650     local_free (dictstat_base);
18651
18652     for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18653     {
18654       pot_t *pot_ptr = &pot[pot_pos];
18655
18656       hash_t *hash = &pot_ptr->hash;
18657
18658       local_free (hash->digest);
18659
18660       if (isSalted)
18661       {
18662         local_free (hash->salt);
18663       }
18664     }
18665
18666     local_free (pot);
18667
18668     local_free (all_kernel_rules_cnt);
18669     local_free (all_kernel_rules_buf);
18670
18671     local_free (wl_data->buf);
18672     local_free (wl_data);
18673
18674     local_free (bitmap_s1_a);
18675     local_free (bitmap_s1_b);
18676     local_free (bitmap_s1_c);
18677     local_free (bitmap_s1_d);
18678     local_free (bitmap_s2_a);
18679     local_free (bitmap_s2_b);
18680     local_free (bitmap_s2_c);
18681     local_free (bitmap_s2_d);
18682
18683     #ifdef HAVE_HWMON
18684     local_free (temp_retain_fanspeed_value);
18685     local_free (od_clock_mem_status);
18686     local_free (od_power_control_status);
18687     local_free (nvml_power_limit);
18688     #endif
18689
18690     global_free (devices_param);
18691
18692     global_free (kernel_rules_buf);
18693
18694     global_free (root_css_buf);
18695     global_free (markov_css_buf);
18696
18697     global_free (digests_buf);
18698     global_free (digests_shown);
18699     global_free (digests_shown_tmp);
18700
18701     global_free (salts_buf);
18702     global_free (salts_shown);
18703
18704     global_free (esalts_buf);
18705
18706     global_free (words_progress_done);
18707     global_free (words_progress_rejected);
18708     global_free (words_progress_restored);
18709
18710     if (pot_fp) fclose (pot_fp);
18711
18712     if (data.devices_status == STATUS_QUIT) break;
18713   }
18714
18715   // wait for interactive threads
18716
18717   for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18718   {
18719     hc_thread_wait (1, &i_threads[thread_idx]);
18720   }
18721
18722   local_free (i_threads);
18723
18724   // destroy others mutex
18725
18726   hc_thread_mutex_delete (mux_dispatcher);
18727   hc_thread_mutex_delete (mux_counter);
18728   hc_thread_mutex_delete (mux_display);
18729   hc_thread_mutex_delete (mux_adl);
18730
18731   // free memory
18732
18733   local_free (eff_restore_file);
18734   local_free (new_restore_file);
18735
18736   local_free (rd);
18737
18738   // tuning db
18739
18740   tuning_db_destroy (tuning_db);
18741
18742   // loopback
18743
18744   local_free (loopback_file);
18745
18746   if (loopback == 1) unlink (loopback_file);
18747
18748   // induction directory
18749
18750   if (induction_dir == NULL)
18751   {
18752     if (attack_mode != ATTACK_MODE_BF)
18753     {
18754       if (rmdir (induction_directory) == -1)
18755       {
18756         if (errno == ENOENT)
18757         {
18758           // good, we can ignore
18759         }
18760         else if (errno == ENOTEMPTY)
18761         {
18762           // good, we can ignore
18763         }
18764         else
18765         {
18766           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18767
18768           return (-1);
18769         }
18770       }
18771
18772       local_free (induction_directory);
18773     }
18774   }
18775
18776   // outfile-check directory
18777
18778   if (outfile_check_dir == NULL)
18779   {
18780     if (rmdir (outfile_check_directory) == -1)
18781     {
18782       if (errno == ENOENT)
18783       {
18784         // good, we can ignore
18785       }
18786       else if (errno == ENOTEMPTY)
18787       {
18788         // good, we can ignore
18789       }
18790       else
18791       {
18792         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18793
18794         return (-1);
18795       }
18796     }
18797
18798     local_free (outfile_check_directory);
18799   }
18800
18801   time_t proc_stop;
18802
18803   time (&proc_stop);
18804
18805   logfile_top_uint (proc_start);
18806   logfile_top_uint (proc_stop);
18807
18808   logfile_top_msg ("STOP");
18809
18810   if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18811   if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18812
18813   if (data.ocl) ocl_close (data.ocl);
18814
18815   if (data.devices_status == STATUS_ABORTED)            return 2;
18816   if (data.devices_status == STATUS_QUIT)               return 2;
18817   if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18818   if (data.devices_status == STATUS_EXHAUSTED)          return 1;
18819   if (data.devices_status == STATUS_CRACKED)            return 0;
18820
18821   return -1;
18822 }