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 __APPLE__
  10 #include <stdio.h>
  11 #endif
  12
  13 #ifdef __FreeBSD__
  14 #include <stdio.h>
  15 #endif
  16
  17 #include <common.h>
  18 #include <shared.h>
  19 #include <rp_kernel_on_cpu.h>
  20 #include <getopt.h>
  21
  22 const char *PROGNAME            = "hashcat";
  23 const uint  VERSION_BIN         = 300;
  24 const uint  RESTORE_MIN         = 300;
  25
  26 double TARGET_MS_PROFILE[4]     = { 2, 12, 96, 480 };
  27
  28 #define INCR_RULES              10000
  29 #define INCR_SALTS              100000
  30 #define INCR_MASKS              1000
  31 #define INCR_POT                1000
  32
  33 #define USAGE                   0
  34 #define VERSION                 0
  35 #define QUIET                   0
  36 #define MARKOV_THRESHOLD        0
  37 #define MARKOV_DISABLE          0
  38 #define MARKOV_CLASSIC          0
  39 #define BENCHMARK               0
  40 #define STDOUT_FLAG             0
  41 #define RESTORE                 0
  42 #define RESTORE_TIMER           60
  43 #define RESTORE_DISABLE         0
  44 #define STATUS                  0
  45 #define STATUS_TIMER            10
  46 #define MACHINE_READABLE        0
  47 #define LOOPBACK                0
  48 #define WEAK_HASH_THRESHOLD     100
  49 #define SHOW                    0
  50 #define LEFT                    0
  51 #define USERNAME                0
  52 #define REMOVE                  0
  53 #define REMOVE_TIMER            60
  54 #define SKIP                    0
  55 #define LIMIT                   0
  56 #define KEYSPACE                0
  57 #define POTFILE_DISABLE         0
  58 #define DEBUG_MODE              0
  59 #define RP_GEN                  0
  60 #define RP_GEN_FUNC_MIN         1
  61 #define RP_GEN_FUNC_MAX         4
  62 #define RP_GEN_SEED             0
  63 #define RULE_BUF_L              ":"
  64 #define RULE_BUF_R              ":"
  65 #define FORCE                   0
  66 #define RUNTIME                 0
  67 #define HEX_CHARSET             0
  68 #define HEX_SALT                0
  69 #define HEX_WORDLIST            0
  70 #define OUTFILE_FORMAT          3
  71 #define OUTFILE_AUTOHEX         1
  72 #define OUTFILE_CHECK_TIMER     5
  73 #define ATTACK_MODE             0
  74 #define HASH_MODE               0
  75 #define SEGMENT_SIZE            32
  76 #define INCREMENT               0
  77 #define INCREMENT_MIN           1
  78 #define INCREMENT_MAX           PW_MAX
  79 #define SEPARATOR               ':'
  80 #define BITMAP_MIN              16
  81 #define BITMAP_MAX              24
  82 #define NVIDIA_SPIN_DAMP        100
  83 #define GPU_TEMP_DISABLE        0
  84 #define GPU_TEMP_ABORT          90
  85 #define GPU_TEMP_RETAIN         75
  86 #define WORKLOAD_PROFILE        2
  87 #define KERNEL_ACCEL            0
  88 #define KERNEL_LOOPS            0
  89 #define KERNEL_RULES            1024
  90 #define KERNEL_COMBS            1024
  91 #define KERNEL_BFS              1024
  92 #define KERNEL_THREADS_MAX      256
  93 #define KERNEL_THREADS_MAX_CPU  1
  94 #define POWERTUNE_ENABLE        0
  95 #define LOGFILE_DISABLE         0
  96 #define SCRYPT_TMTO             0
  97 #define OPENCL_VECTOR_WIDTH     0
  98
  99 #define WL_MODE_STDIN           1
 100 #define WL_MODE_FILE            2
 101 #define WL_MODE_MASK            3
 102
 103 #define HL_MODE_FILE            4
 104 #define HL_MODE_ARG             5
 105
 106 #define HLFMTS_CNT              11
 107 #define HLFMT_HASHCAT           0
 108 #define HLFMT_PWDUMP            1
 109 #define HLFMT_PASSWD            2
 110 #define HLFMT_SHADOW            3
 111 #define HLFMT_DCC               4
 112 #define HLFMT_DCC2              5
 113 #define HLFMT_NETNTLM1          7
 114 #define HLFMT_NETNTLM2          8
 115 #define HLFMT_NSLDAP            9
 116 #define HLFMT_NSLDAPS           10
 117
 118 #define HLFMT_TEXT_HASHCAT      "native hashcat"
 119 #define HLFMT_TEXT_PWDUMP       "pwdump"
 120 #define HLFMT_TEXT_PASSWD       "passwd"
 121 #define HLFMT_TEXT_SHADOW       "shadow"
 122 #define HLFMT_TEXT_DCC          "DCC"
 123 #define HLFMT_TEXT_DCC2         "DCC 2"
 124 #define HLFMT_TEXT_NETNTLM1     "NetNTLMv1"
 125 #define HLFMT_TEXT_NETNTLM2     "NetNTLMv2"
 126 #define HLFMT_TEXT_NSLDAP       "nsldap"
 127 #define HLFMT_TEXT_NSLDAPS      "nsldaps"
 128
 129 #define ATTACK_MODE_STRAIGHT    0
 130 #define ATTACK_MODE_COMBI       1
 131 #define ATTACK_MODE_TOGGLE      2
 132 #define ATTACK_MODE_BF          3
 133 #define ATTACK_MODE_PERM        4
 134 #define ATTACK_MODE_TABLE       5
 135 #define ATTACK_MODE_HYBRID1     6
 136 #define ATTACK_MODE_HYBRID2     7
 137 #define ATTACK_MODE_NONE        100
 138
 139 #define ATTACK_KERN_STRAIGHT    0
 140 #define ATTACK_KERN_COMBI       1
 141 #define ATTACK_KERN_BF          3
 142 #define ATTACK_KERN_NONE        100
 143
 144 #define ATTACK_EXEC_OUTSIDE_KERNEL  10
 145 #define ATTACK_EXEC_INSIDE_KERNEL   11
 146
 147 #define COMBINATOR_MODE_BASE_LEFT   10001
 148 #define COMBINATOR_MODE_BASE_RIGHT  10002
 149
 150 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 151 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 152
 153 #define MAX_CUT_TRIES           4
 154
 155 #define MAX_DICTSTAT            10000
 156
 157 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
 158
 159 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
 160
 161 #define global_free(attr)       \
 162 {                               \
 163   myfree ((void *) data.attr);  \
 164                                 \
 165   data.attr = NULL;             \
 166 }
 167
 168 #define local_free(attr)  \
 169 {                         \
 170   myfree ((void *) attr); \
 171                           \
 172   attr = NULL;            \
 173 }
 174
 175 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 176 #define HC_API_CALL __stdcall
 177 #else
 178 #define HC_API_CALL
 179 #endif
 180
 181 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
 182 {
 183   900,
 184   0,
 185   5100,
 186   100,
 187   1400,
 188   10800,
 189   1700,
 190   5000,
 191   10100,
 192   6000,
 193   6100,
 194   6900,
 195   11700,
 196   11800,
 197   400,
 198   8900,
 199   11900,
 200   12000,
 201   10900,
 202   12100,
 203   23,
 204   2500,
 205   5300,
 206   5400,
 207   5500,
 208   5600,
 209   7300,
 210   7500,
 211   13100,
 212   8300,
 213   11100,
 214   11200,
 215   11400,
 216   121,
 217   2611,
 218   2711,
 219   2811,
 220   8400,
 221   11,
 222   2612,
 223   7900,
 224   21,
 225   11000,
 226   124,
 227   10000,
 228   3711,
 229   7600,
 230   12,
 231   131,
 232   132,
 233   1731,
 234   200,
 235   300,
 236   3100,
 237   112,
 238   12300,
 239   8000,
 240   141,
 241   1441,
 242   1600,
 243   12600,
 244   1421,
 245   101,
 246   111,
 247   1711,
 248   3000,
 249   1000,
 250   1100,
 251   2100,
 252   12800,
 253   1500,
 254   12400,
 255   500,
 256   3200,
 257   7400,
 258   1800,
 259   122,
 260   1722,
 261   7100,
 262   6300,
 263   6700,
 264   6400,
 265   6500,
 266   2400,
 267   2410,
 268   5700,
 269   9200,
 270   9300,
 271   22,
 272   501,
 273   5800,
 274   8100,
 275   8500,
 276   7200,
 277   9900,
 278   7700,
 279   7800,
 280   10300,
 281   8600,
 282   8700,
 283   9100,
 284   133,
 285   13500,
 286   11600,
 287   13600,
 288   12500,
 289   13000,
 290   13200,
 291   13300,
 292   6211,
 293   6221,
 294   6231,
 295   6241,
 296   13711,
 297   13721,
 298   13731,
 299   13741,
 300   13751,
 301   13761,
 302   8800,
 303   12900,
 304   12200,
 305   9700,
 306   9710,
 307   9800,
 308   9810,
 309   9400,
 310   9500,
 311   9600,
 312   10400,
 313   10410,
 314   10500,
 315   10600,
 316   10700,
 317   9000,
 318   5200,
 319   6800,
 320   6600,
 321   8200,
 322   11300,
 323   12700,
 324   13400,
 325   125
 326 };
 327
 328 /**
 329  * types
 330  */
 331
 332 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
 333
 334 /**
 335  * globals
 336  */
 337
 338 static unsigned int full01 = 0x01010101;
 339 static unsigned int full80 = 0x80808080;
 340
 341 int SUPPRESS_OUTPUT = 0;
 342
 343 hc_thread_mutex_t mux_adl;
 344 hc_thread_mutex_t mux_counter;
 345 hc_thread_mutex_t mux_dispatcher;
 346 hc_thread_mutex_t mux_display;
 347
 348 hc_global_data_t data;
 349
 350 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
 351
 352 const char *USAGE_MINI[] =
 353 {
 354   "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
 355   "",
 356   "Try --help for more help.",
 357   NULL
 358 };
 359
 360 const char *USAGE_BIG[] =
 361 {
 362   "%s, advanced password recovery",
 363   "",
 364   "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
 365   "",
 366   "- [ Options ] -",
 367   "",
 368   " Options Short / Long          | Type | Description                                          | Example",
 369   "===============================+======+======================================================+=======================",
 370   " -m, --hash-type               | Num  | Hash-type, see references below                      | -m 1000",
 371   " -a, --attack-mode             | Num  | Attack-mode, see references below                    | -a 3",
 372   " -V, --version                 |      | Print version                                        |",
 373   " -h, --help                    |      | Print help                                           |",
 374   "     --quiet                   |      | Suppress output                                      |",
 375   "     --hex-charset             |      | Assume charset is given in hex                       |",
 376   "     --hex-salt                |      | Assume salt is given in hex                          |",
 377   "     --hex-wordlist            |      | Assume words in wordlist is given in hex             |",
 378   "     --force                   |      | Ignore warnings                                      |",
 379   "     --status                  |      | Enable automatic update of the status-screen         |",
 380   "     --status-timer            | Num  | Sets seconds between status-screen update to X       | --status-timer=1",
 381   "     --machine-readable        |      | Display the status view in a machine readable format |",
 382   "     --loopback                |      | Add new plains to induct directory                   |",
 383   "     --weak-hash-threshold     | Num  | Threshold X when to stop checking for weak hashes    | --weak=0",
 384   "     --markov-hcstat           | File | Specify hcstat file to use                           | --markov-hc=my.hcstat",
 385   "     --markov-disable          |      | Disables markov-chains, emulates classic brute-force |",
 386   "     --markov-classic          |      | Enables classic markov-chains, no per-position       |",
 387   " -t, --markov-threshold        | Num  | Threshold X when to stop accepting new markov-chains | -t 50",
 388   "     --runtime                 | Num  | Abort session after X seconds of runtime             | --runtime=10",
 389   "     --session                 | Str  | Define specific session name                         | --session=mysession",
 390   "     --restore                 |      | Restore session from --session                       |",
 391   "     --restore-disable         |      | Do not write restore file                            |",
 392   " -o, --outfile                 | File | Define outfile for recovered hash                    | -o outfile.txt",
 393   "     --outfile-format          | Num  | Define outfile-format X for recovered hash           | --outfile-format=7",
 394   "     --outfile-autohex-disable |      | Disable the use of $HEX[] in output plains           |",
 395   "     --outfile-check-timer     | Num  | Sets seconds between outfile checks to X             | --outfile-check=30",
 396   " -p, --separator               | Char | Separator char for hashlists and outfile             | -p :",
 397   "     --stdout                  |      | Do not crack a hash, instead print candidates only   |",
 398   "     --show                    |      | Compare hashlist with potfile; Show cracked hashes   |",
 399   "     --left                    |      | Compare hashlist with potfile; Show uncracked hashes |",
 400   "     --username                |      | Enable ignoring of usernames in hashfile             |",
 401   "     --remove                  |      | Enable remove of hash once it is cracked             |",
 402   "     --remove-timer            | Num  | Update input hash file each X seconds                | --remove-timer=30",
 403   "     --potfile-disable         |      | Do not write potfile                                 |",
 404   "     --potfile-path            | Dir  | Specific path to potfile                             | --potfile-path=my.pot",
 405   "     --debug-mode              | Num  | Defines the debug mode (hybrid only by using rules)  | --debug-mode=4",
 406   "     --debug-file              | File | Output file for debugging rules                      | --debug-file=good.log",
 407   "     --induction-dir           | Dir  | Specify the induction directory to use for loopback  | --induction=inducts",
 408   "     --outfile-check-dir       | Dir  | Specify the outfile directory to monitor for plains  | --outfile-check-dir=x",
 409   "     --logfile-disable         |      | Disable the logfile                                  |",
 410   "     --truecrypt-keyfiles      | File | Keyfiles used, separate with comma                   | --truecrypt-key=x.png",
 411   "     --veracrypt-keyfiles      | File | Keyfiles used, separate with comma                   | --veracrypt-key=x.txt",
 412   "     --veracrypt-pim           | Num  | VeraCrypt personal iterations multiplier             | --veracrypt-pim=1000",
 413   " -b, --benchmark               |      | Run benchmark                                        |",
 414   " -c, --segment-size            | Num  | Sets size in MB to cache from the wordfile to X      | -c 32",
 415   "     --bitmap-min              | Num  | Sets minimum bits allowed for bitmaps to X           | --bitmap-min=24",
 416   "     --bitmap-max              | Num  | Sets maximum bits allowed for bitmaps to X           | --bitmap-min=24",
 417   "     --cpu-affinity            | Str  | Locks to CPU devices, separate with comma            | --cpu-affinity=1,2,3",
 418   "     --opencl-platforms        | Str  | OpenCL platforms to use, separate with comma         | --opencl-platforms=2",
 419   " -d, --opencl-devices          | Str  | OpenCL devices to use, separate with comma           | -d 1",
 420   " -D, --opencl-device-types     | Str  | OpenCL device-types to use, separate with comma      | -D 1",
 421   "     --opencl-vector-width     | Num  | Manual override OpenCL vector-width to X             | --opencl-vector=4",
 422   " -w, --workload-profile        | Num  | Enable a specific workload profile, see pool below   | -w 3",
 423   " -n, --kernel-accel            | Num  | Manual workload tuning, set outerloop step size to X | -n 64",
 424   " -u, --kernel-loops            | Num  | Manual workload tuning, set innerloop step size to X | -u 256",
 425   "     --nvidia-spin-damp        | Num  | Workaround NVidias CPU burning loop bug, in percent  | --nvidia-spin-damp=50",
 426   "     --gpu-temp-disable        |      | Disable temperature and fanspeed reads and triggers  |",
 427   #ifdef HAVE_HWMON
 428   "     --gpu-temp-abort          | Num  | Abort if GPU temperature reaches X degrees celsius   | --gpu-temp-abort=100",
 429   "     --gpu-temp-retain         | Num  | Try to retain GPU temperature at X degrees celsius   | --gpu-temp-retain=95",
 430   "     --powertune-enable        |      | Enable power tuning, restores settings when finished |",
 431   #endif
 432   "     --scrypt-tmto             | Num  | Manually override TMTO value for scrypt to X         | --scrypt-tmto=3",
 433   " -s, --skip                    | Num  | Skip X words from the start                          | -s 1000000",
 434   " -l, --limit                   | Num  | Limit X words from the start + skipped words         | -l 1000000",
 435   "     --keyspace                |      | Show keyspace base:mod values and quit               |",
 436   " -j, --rule-left               | Rule | Single rule applied to each word from left wordlist  | -j 'c'",
 437   " -k, --rule-right              | Rule | Single rule applied to each word from right wordlist | -k '^-'",
 438   " -r, --rules-file              | File | Multiple rules applied to each word from wordlists   | -r rules/best64.rule",
 439   " -g, --generate-rules          | Num  | Generate X random rules                              | -g 10000",
 440   "     --generate-rules-func-min | Num  | Force min X funcs per rule                           |",
 441   "     --generate-rules-func-max | Num  | Force max X funcs per rule                           |",
 442   "     --generate-rules-seed     | Num  | Force RNG seed set to X                              |",
 443   " -1, --custom-charset1         | CS   | User-defined charset ?1                              | -1 ?l?d?u",
 444   " -2, --custom-charset2         | CS   | User-defined charset ?2                              | -2 ?l?d?s",
 445   " -3, --custom-charset3         | CS   | User-defined charset ?3                              |",
 446   " -4, --custom-charset4         | CS   | User-defined charset ?4                              |",
 447   " -i, --increment               |      | Enable mask increment mode                           |",
 448   "     --increment-min           | Num  | Start mask incrementing at X                         | --increment-min=4",
 449   "     --increment-max           | Num  | Stop mask incrementing at X                          | --increment-max=8",
 450   "",
 451   "- [ Hash modes ] -",
 452   "",
 453   "      # | Name                                             | Category",
 454   "  ======+==================================================+======================================",
 455   "    900 | MD4                                              | Raw Hash",
 456   "      0 | MD5                                              | Raw Hash",
 457   "   5100 | Half MD5                                         | Raw Hash",
 458   "    100 | SHA1                                             | Raw Hash",
 459   "  10800 | SHA-384                                          | Raw Hash",
 460   "   1400 | SHA-256                                          | Raw Hash",
 461   "   1700 | SHA-512                                          | Raw Hash",
 462   "   5000 | SHA-3(Keccak)                                    | Raw Hash",
 463   "  10100 | SipHash                                          | Raw Hash",
 464   "   6000 | RipeMD160                                        | Raw Hash",
 465   "   6100 | Whirlpool                                        | Raw Hash",
 466   "   6900 | GOST R 34.11-94                                  | Raw Hash",
 467   "  11700 | GOST R 34.11-2012 (Streebog) 256-bit             | Raw Hash",
 468   "  11800 | GOST R 34.11-2012 (Streebog) 512-bit             | Raw Hash",
 469   "     10 | md5($pass.$salt)                                 | Raw Hash, Salted and / or Iterated",
 470   "     20 | md5($salt.$pass)                                 | Raw Hash, Salted and / or Iterated",
 471   "     30 | md5(unicode($pass).$salt)                        | Raw Hash, Salted and / or Iterated",
 472   "     40 | md5($salt.unicode($pass))                        | Raw Hash, Salted and / or Iterated",
 473   "   3800 | md5($salt.$pass.$salt)                           | Raw Hash, Salted and / or Iterated",
 474   "   3710 | md5($salt.md5($pass))                            | Raw Hash, Salted and / or Iterated",
 475   "   2600 | md5(md5($pass))                                  | Raw Hash, Salted and / or Iterated",
 476   "   4300 | md5(strtoupper(md5($pass)))                      | Raw Hash, Salted and / or Iterated",
 477   "   4400 | md5(sha1($pass))                                 | Raw Hash, Salted and / or Iterated",
 478   "    110 | sha1($pass.$salt)                                | Raw Hash, Salted and / or Iterated",
 479   "    120 | sha1($salt.$pass)                                | Raw Hash, Salted and / or Iterated",
 480   "    130 | sha1(unicode($pass).$salt)                       | Raw Hash, Salted and / or Iterated",
 481   "    140 | sha1($salt.unicode($pass))                       | Raw Hash, Salted and / or Iterated",
 482   "   4500 | sha1(sha1($pass))                                | Raw Hash, Salted and / or Iterated",
 483   "   4700 | sha1(md5($pass))                                 | Raw Hash, Salted and / or Iterated",
 484   "   4900 | sha1($salt.$pass.$salt)                          | Raw Hash, Salted and / or Iterated",
 485   "   1410 | sha256($pass.$salt)                              | Raw Hash, Salted and / or Iterated",
 486   "   1420 | sha256($salt.$pass)                              | Raw Hash, Salted and / or Iterated",
 487   "   1430 | sha256(unicode($pass).$salt)                     | Raw Hash, Salted and / or Iterated",
 488   "   1440 | sha256($salt.unicode($pass))                     | Raw Hash, Salted and / or Iterated",
 489   "   1710 | sha512($pass.$salt)                              | Raw Hash, Salted and / or Iterated",
 490   "   1720 | sha512($salt.$pass)                              | Raw Hash, Salted and / or Iterated",
 491   "   1730 | sha512(unicode($pass).$salt)                     | Raw Hash, Salted and / or Iterated",
 492   "   1740 | sha512($salt.unicode($pass))                     | Raw Hash, Salted and / or Iterated",
 493   "     50 | HMAC-MD5 (key = $pass)                           | Raw Hash, Authenticated",
 494   "     60 | HMAC-MD5 (key = $salt)                           | Raw Hash, Authenticated",
 495   "    150 | HMAC-SHA1 (key = $pass)                          | Raw Hash, Authenticated",
 496   "    160 | HMAC-SHA1 (key = $salt)                          | Raw Hash, Authenticated",
 497   "   1450 | HMAC-SHA256 (key = $pass)                        | Raw Hash, Authenticated",
 498   "   1460 | HMAC-SHA256 (key = $salt)                        | Raw Hash, Authenticated",
 499   "   1750 | HMAC-SHA512 (key = $pass)                        | Raw Hash, Authenticated",
 500   "   1760 | HMAC-SHA512 (key = $salt)                        | Raw Hash, Authenticated",
 501   "    400 | phpass                                           | Generic KDF",
 502   "   8900 | scrypt                                           | Generic KDF",
 503   "  11900 | PBKDF2-HMAC-MD5                                  | Generic KDF",
 504   "  12000 | PBKDF2-HMAC-SHA1                                 | Generic KDF",
 505   "  10900 | PBKDF2-HMAC-SHA256                               | Generic KDF",
 506   "  12100 | PBKDF2-HMAC-SHA512                               | Generic KDF",
 507   "     23 | Skype                                            | Network protocols",
 508   "   2500 | WPA/WPA2                                         | Network protocols",
 509   "   4800 | iSCSI CHAP authentication, MD5(Chap)             | Network protocols",
 510   "   5300 | IKE-PSK MD5                                      | Network protocols",
 511   "   5400 | IKE-PSK SHA1                                     | Network protocols",
 512   "   5500 | NetNTLMv1                                        | Network protocols",
 513   "   5500 | NetNTLMv1 + ESS                                  | Network protocols",
 514   "   5600 | NetNTLMv2                                        | Network protocols",
 515   "   7300 | IPMI2 RAKP HMAC-SHA1                             | Network protocols",
 516   "   7500 | Kerberos 5 AS-REQ Pre-Auth etype 23              | Network protocols",
 517   "   8300 | DNSSEC (NSEC3)                                   | Network protocols",
 518   "  10200 | Cram MD5                                         | Network protocols",
 519   "  11100 | PostgreSQL CRAM (MD5)                            | Network protocols",
 520   "  11200 | MySQL CRAM (SHA1)                                | Network protocols",
 521   "  11400 | SIP digest authentication (MD5)                  | Network protocols",
 522   "  13100 | Kerberos 5 TGS-REP etype 23                      | Network protocols",
 523   "    121 | SMF (Simple Machines Forum)                      | Forums, CMS, E-Commerce, Frameworks",
 524   "    400 | phpBB3                                           | Forums, CMS, E-Commerce, Frameworks",
 525   "   2611 | vBulletin < v3.8.5                               | Forums, CMS, E-Commerce, Frameworks",
 526   "   2711 | vBulletin > v3.8.5                               | Forums, CMS, E-Commerce, Frameworks",
 527   "   2811 | MyBB                                             | Forums, CMS, E-Commerce, Frameworks",
 528   "   2811 | IPB (Invison Power Board)                        | Forums, CMS, E-Commerce, Frameworks",
 529   "   8400 | WBB3 (Woltlab Burning Board)                     | Forums, CMS, E-Commerce, Frameworks",
 530   "     11 | Joomla < 2.5.18                                  | Forums, CMS, E-Commerce, Frameworks",
 531   "    400 | Joomla > 2.5.18                                  | Forums, CMS, E-Commerce, Frameworks",
 532   "    400 | Wordpress                                        | Forums, CMS, E-Commerce, Frameworks",
 533   "   2612 | PHPS                                             | Forums, CMS, E-Commerce, Frameworks",
 534   "   7900 | Drupal7                                          | Forums, CMS, E-Commerce, Frameworks",
 535   "     21 | osCommerce                                       | Forums, CMS, E-Commerce, Frameworks",
 536   "     21 | xt:Commerce                                      | Forums, CMS, E-Commerce, Frameworks",
 537   "  11000 | PrestaShop                                       | Forums, CMS, E-Commerce, Frameworks",
 538   "    124 | Django (SHA-1)                                   | Forums, CMS, E-Commerce, Frameworks",
 539   "  10000 | Django (PBKDF2-SHA256)                           | Forums, CMS, E-Commerce, Frameworks",
 540   "   3711 | Mediawiki B type                                 | Forums, CMS, E-Commerce, Frameworks",
 541   "   7600 | Redmine                                          | Forums, CMS, E-Commerce, Frameworks",
 542   "     12 | PostgreSQL                                       | Database Server",
 543   "    131 | MSSQL(2000)                                      | Database Server",
 544   "    132 | MSSQL(2005)                                      | Database Server",
 545   "   1731 | MSSQL(2012)                                      | Database Server",
 546   "   1731 | MSSQL(2014)                                      | Database Server",
 547   "    200 | MySQL323                                         | Database Server",
 548   "    300 | MySQL4.1/MySQL5                                  | Database Server",
 549   "   3100 | Oracle H: Type (Oracle 7+)                       | Database Server",
 550   "    112 | Oracle S: Type (Oracle 11+)                      | Database Server",
 551   "  12300 | Oracle T: Type (Oracle 12+)                      | Database Server",
 552   "   8000 | Sybase ASE                                       | Database Server",
 553   "    141 | EPiServer 6.x < v4                               | HTTP, SMTP, LDAP Server",
 554   "   1441 | EPiServer 6.x > v4                               | HTTP, SMTP, LDAP Server",
 555   "   1600 | Apache $apr1$                                    | HTTP, SMTP, LDAP Server",
 556   "  12600 | ColdFusion 10+                                   | HTTP, SMTP, LDAP Server",
 557   "   1421 | hMailServer                                      | HTTP, SMTP, LDAP Server",
 558   "    101 | nsldap, SHA-1(Base64), Netscape LDAP SHA         | HTTP, SMTP, LDAP Server",
 559   "    111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA      | HTTP, SMTP, LDAP Server",
 560   "   1711 | SSHA-512(Base64), LDAP {SSHA512}                 | HTTP, SMTP, LDAP Server",
 561   "  11500 | CRC32                                            | Checksums",
 562   "   3000 | LM                                               | Operating-Systems",
 563   "   1000 | NTLM                                             | Operating-Systems",
 564   "   1100 | Domain Cached Credentials (DCC), MS Cache        | Operating-Systems",
 565   "   2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2   | Operating-Systems",
 566   "  12800 | MS-AzureSync PBKDF2-HMAC-SHA256                  | Operating-Systems",
 567   "   1500 | descrypt, DES(Unix), Traditional DES             | Operating-Systems",
 568   "  12400 | BSDiCrypt, Extended DES                          | Operating-Systems",
 569   "    500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems",
 570   "   3200 | bcrypt $2*$, Blowfish(Unix)                      | Operating-Systems",
 571   "   7400 | sha256crypt $5$, SHA256(Unix)                    | Operating-Systems",
 572   "   1800 | sha512crypt $6$, SHA512(Unix)                    | Operating-Systems",
 573   "    122 | OSX v10.4, OSX v10.5, OSX v10.6                  | Operating-Systems",
 574   "   1722 | OSX v10.7                                        | Operating-Systems",
 575   "   7100 | OSX v10.8, OSX v10.9, OSX v10.10                 | Operating-Systems",
 576   "   6300 | AIX {smd5}                                       | Operating-Systems",
 577   "   6700 | AIX {ssha1}                                      | Operating-Systems",
 578   "   6400 | AIX {ssha256}                                    | Operating-Systems",
 579   "   6500 | AIX {ssha512}                                    | Operating-Systems",
 580   "   2400 | Cisco-PIX                                        | Operating-Systems",
 581   "   2410 | Cisco-ASA                                        | Operating-Systems",
 582   "    500 | Cisco-IOS $1$                                    | Operating-Systems",
 583   "   5700 | Cisco-IOS $4$                                    | Operating-Systems",
 584   "   9200 | Cisco-IOS $8$                                    | Operating-Systems",
 585   "   9300 | Cisco-IOS $9$                                    | Operating-Systems",
 586   "     22 | Juniper Netscreen/SSG (ScreenOS)                 | Operating-Systems",
 587   "    501 | Juniper IVE                                      | Operating-Systems",
 588   "   5800 | Android PIN                                      | Operating-Systems",
 589   "  13800 | Windows 8+ phone PIN/Password                    | Operating-Systems",
 590   "   8100 | Citrix Netscaler                                 | Operating-Systems",
 591   "   8500 | RACF                                             | Operating-Systems",
 592   "   7200 | GRUB 2                                           | Operating-Systems",
 593   "   9900 | Radmin2                                          | Operating-Systems",
 594   "    125 | ArubaOS                                          | Operating-Systems",
 595   "   7700 | SAP CODVN B (BCODE)                              | Enterprise Application Software (EAS)",
 596   "   7800 | SAP CODVN F/G (PASSCODE)                         | Enterprise Application Software (EAS)",
 597   "  10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1              | Enterprise Application Software (EAS)",
 598   "   8600 | Lotus Notes/Domino 5                             | Enterprise Application Software (EAS)",
 599   "   8700 | Lotus Notes/Domino 6                             | Enterprise Application Software (EAS)",
 600   "   9100 | Lotus Notes/Domino 8                             | Enterprise Application Software (EAS)",
 601   "    133 | PeopleSoft                                       | Enterprise Application Software (EAS)",
 602   "  13500 | PeopleSoft Token                                 | Enterprise Application Software (EAS)",
 603   "  11600 | 7-Zip                                            | Archives",
 604   "  12500 | RAR3-hp                                          | Archives",
 605   "  13000 | RAR5                                             | Archives",
 606   "  13200 | AxCrypt                                          | Archives",
 607   "  13300 | AxCrypt in memory SHA1                           | Archives",
 608   "  13600 | WinZip                                           | Archives",
 609   "   62XY | TrueCrypt                                        | Full-Disk encryptions (FDE)",
 610   "     X  | 1 = PBKDF2-HMAC-RipeMD160                        | Full-Disk encryptions (FDE)",
 611   "     X  | 2 = PBKDF2-HMAC-SHA512                           | Full-Disk encryptions (FDE)",
 612   "     X  | 3 = PBKDF2-HMAC-Whirlpool                        | Full-Disk encryptions (FDE)",
 613   "     X  | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode            | Full-Disk encryptions (FDE)",
 614   "      Y | 1 = XTS  512 bit pure AES                        | Full-Disk encryptions (FDE)",
 615   "      Y | 1 = XTS  512 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 616   "      Y | 1 = XTS  512 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 617   "      Y | 2 = XTS 1024 bit pure AES                        | Full-Disk encryptions (FDE)",
 618   "      Y | 2 = XTS 1024 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 619   "      Y | 2 = XTS 1024 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 620   "      Y | 2 = XTS 1024 bit cascaded AES-Twofish            | Full-Disk encryptions (FDE)",
 621   "      Y | 2 = XTS 1024 bit cascaded Serpent-AES            | Full-Disk encryptions (FDE)",
 622   "      Y | 2 = XTS 1024 bit cascaded Twofish-Serpent        | Full-Disk encryptions (FDE)",
 623   "      Y | 3 = XTS 1536 bit all                             | Full-Disk encryptions (FDE)",
 624   "   8800 | Android FDE < v4.3                               | Full-Disk encryptions (FDE)",
 625   "  12900 | Android FDE (Samsung DEK)                        | Full-Disk encryptions (FDE)",
 626   "  12200 | eCryptfs                                         | Full-Disk encryptions (FDE)",
 627   "  137XY | VeraCrypt                                        | Full-Disk encryptions (FDE)",
 628   "     X  | 1 = PBKDF2-HMAC-RipeMD160                        | Full-Disk encryptions (FDE)",
 629   "     X  | 2 = PBKDF2-HMAC-SHA512                           | Full-Disk encryptions (FDE)",
 630   "     X  | 3 = PBKDF2-HMAC-Whirlpool                        | Full-Disk encryptions (FDE)",
 631   "     X  | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode            | Full-Disk encryptions (FDE)",
 632   "     X  | 5 = PBKDF2-HMAC-SHA256                           | Full-Disk encryptions (FDE)",
 633   "     X  | 6 = PBKDF2-HMAC-SHA256 + boot-mode               | Full-Disk encryptions (FDE)",
 634   "      Y | 1 = XTS  512 bit pure AES                        | Full-Disk encryptions (FDE)",
 635   "      Y | 1 = XTS  512 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 636   "      Y | 1 = XTS  512 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 637   "      Y | 2 = XTS 1024 bit pure AES                        | Full-Disk encryptions (FDE)",
 638   "      Y | 2 = XTS 1024 bit pure Serpent                    | Full-Disk encryptions (FDE)",
 639   "      Y | 2 = XTS 1024 bit pure Twofish                    | Full-Disk encryptions (FDE)",
 640   "      Y | 2 = XTS 1024 bit cascaded AES-Twofish            | Full-Disk encryptions (FDE)",
 641   "      Y | 2 = XTS 1024 bit cascaded Serpent-AES            | Full-Disk encryptions (FDE)",
 642   "      Y | 2 = XTS 1024 bit cascaded Twofish-Serpent        | Full-Disk encryptions (FDE)",
 643   "      Y | 3 = XTS 1536 bit all                             | Full-Disk encryptions (FDE)",
 644   "   9700 | MS Office <= 2003 $0|$1, MD5 + RC4               | Documents",
 645   "   9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1  | Documents",
 646   "   9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2  | Documents",
 647   "   9800 | MS Office <= 2003 $3|$4, SHA1 + RC4              | Documents",
 648   "   9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
 649   "   9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
 650   "   9400 | MS Office 2007                                   | Documents",
 651   "   9500 | MS Office 2010                                   | Documents",
 652   "   9600 | MS Office 2013                                   | Documents",
 653   "  10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4)                    | Documents",
 654   "  10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1       | Documents",
 655   "  10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2       | Documents",
 656   "  10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8)                    | Documents",
 657   "  10600 | PDF 1.7 Level 3 (Acrobat 9)                      | Documents",
 658   "  10700 | PDF 1.7 Level 8 (Acrobat 10 - 11)                | Documents",
 659   "   9000 | Password Safe v2                                 | Password Managers",
 660   "   5200 | Password Safe v3                                 | Password Managers",
 661   "   6800 | Lastpass + Lastpass sniffed                      | Password Managers",
 662   "   6600 | 1Password, agilekeychain                         | Password Managers",
 663   "   8200 | 1Password, cloudkeychain                         | Password Managers",
 664   "  11300 | Bitcoin/Litecoin wallet.dat                      | Password Managers",
 665   "  12700 | Blockchain, My Wallet                            | Password Managers",
 666   "  13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES)      | Password Managers",
 667   "",
 668   "- [ Outfile Formats ] -",
 669   "",
 670   "  # | Format",
 671   " ===+========",
 672   "  1 | hash[:salt]",
 673   "  2 | plain",
 674   "  3 | hash[:salt]:plain",
 675   "  4 | hex_plain",
 676   "  5 | hash[:salt]:hex_plain",
 677   "  6 | plain:hex_plain",
 678   "  7 | hash[:salt]:plain:hex_plain",
 679   "  8 | crackpos",
 680   "  9 | hash[:salt]:crack_pos",
 681   " 10 | plain:crack_pos",
 682   " 11 | hash[:salt]:plain:crack_pos",
 683   " 12 | hex_plain:crack_pos",
 684   " 13 | hash[:salt]:hex_plain:crack_pos",
 685   " 14 | plain:hex_plain:crack_pos",
 686   " 15 | hash[:salt]:plain:hex_plain:crack_pos",
 687   "",
 688   "- [ Rule Debugging Modes ] -",
 689   "",
 690   "  # | Format",
 691   " ===+========",
 692   "  1 | Finding-Rule",
 693   "  2 | Original-Word",
 694   "  3 | Original-Word:Finding-Rule",
 695   "  4 | Original-Word:Finding-Rule:Processed-Word",
 696   "",
 697   "- [ Attack Modes ] -",
 698   "",
 699   "  # | Mode",
 700   " ===+======",
 701   "  0 | Straight",
 702   "  1 | Combination",
 703   "  3 | Brute-force",
 704   "  6 | Hybrid Wordlist + Mask",
 705   "  7 | Hybrid Mask + Wordlist",
 706   "",
 707   "- [ Built-in Charsets ] -",
 708   "",
 709   "  ? | Charset",
 710   " ===+=========",
 711   "  l | abcdefghijklmnopqrstuvwxyz",
 712   "  u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
 713   "  d | 0123456789",
 714   "  s |  !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
 715   "  a | ?l?u?d?s",
 716   "  b | 0x00 - 0xff",
 717   "",
 718   "- [ OpenCL Device Types ] -",
 719   "",
 720   "  # | Device Type",
 721   " ===+=============",
 722   "  1 | CPU",
 723   "  2 | GPU",
 724   "  3 | FPGA, DSP, Co-Processor",
 725   "",
 726   "- [ Workload Profiles ] -",
 727   "",
 728   "  # | Performance | Runtime | Power Consumption | Desktop Impact",
 729   " ===+=============+=========+===================+=================",
 730   "  1 | Low         |   2 ms  | Low               | Minimal",
 731   "  2 | Default     |  12 ms  | Economic          | Noticeable",
 732   "  3 | High        |  96 ms  | High              | Unresponsive",
 733   "  4 | Nightmare   | 480 ms  | Insane            | Headless",
 734   "",
 735   "- [ Basic Examples ] -",
 736   "",
 737   "  Attack-          | Hash- |",
 738   "  Mode             | Type  | Example command",
 739   " ==================+=======+==================================================================",
 740   "  Wordlist         | $P$   | %s -a 0 -m 400 example400.hash example.dict",
 741   "  Wordlist + Rules | MD5   | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
 742   "  Brute-Force      | MD5   | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
 743   "  Combinator       | MD5   | %s -a 1 -m 0 example0.hash example.dict example.dict",
 744   "",
 745   "If you still have no idea what just happened try following pages:",
 746   "",
 747   "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
 748   "* https://hashcat.net/wiki/#frequently_asked_questions",
 749   NULL
 750 };
 751
 752 /**
 753  * hashcat specific functions
 754  */
 755
 756 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
 757 {
 758   int exec_pos = (int) device_param->exec_pos - last_num_entries;
 759
 760   if (exec_pos < 0) exec_pos += EXEC_CACHE;
 761
 762   double exec_ms_sum = 0;
 763
 764   int exec_ms_cnt = 0;
 765
 766   for (int i = 0; i < last_num_entries; i++)
 767   {
 768     double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
 769
 770     if (exec_ms)
 771     {
 772       exec_ms_sum += exec_ms;
 773
 774       exec_ms_cnt++;
 775     }
 776   }
 777
 778   if (exec_ms_cnt == 0) return 0;
 779
 780   return exec_ms_sum / exec_ms_cnt;
 781 }
 782
 783 void status_display_machine_readable ()
 784 {
 785   FILE *out = stdout;
 786
 787   fprintf (out, "STATUS\t%u\t", data.devices_status);
 788
 789   /**
 790    * speed new
 791    */
 792
 793   fprintf (out, "SPEED\t");
 794
 795   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 796   {
 797     hc_device_param_t *device_param = &data.devices_param[device_id];
 798
 799     if (device_param->skipped) continue;
 800
 801     u64    speed_cnt  = 0;
 802     double speed_ms   = 0;
 803
 804     for (int i = 0; i < SPEED_CACHE; i++)
 805     {
 806       speed_cnt  += device_param->speed_cnt[i];
 807       speed_ms   += device_param->speed_ms[i];
 808     }
 809
 810     speed_cnt  /= SPEED_CACHE;
 811     speed_ms   /= SPEED_CACHE;
 812
 813     fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
 814   }
 815
 816   /**
 817    * exec time
 818    */
 819
 820   fprintf (out, "EXEC_RUNTIME\t");
 821
 822   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 823   {
 824     hc_device_param_t *device_param = &data.devices_param[device_id];
 825
 826     if (device_param->skipped) continue;
 827
 828     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
 829
 830     fprintf (out, "%f\t", exec_ms_avg);
 831   }
 832
 833   /**
 834    * words_cur
 835    */
 836
 837   u64 words_cur = get_lowest_words_done ();
 838
 839   fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
 840
 841   /**
 842    * counter
 843    */
 844
 845   u64 progress_total = data.words_cnt * data.salts_cnt;
 846
 847   u64 all_done     = 0;
 848   u64 all_rejected = 0;
 849   u64 all_restored = 0;
 850
 851   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
 852   {
 853     all_done     += data.words_progress_done[salt_pos];
 854     all_rejected += data.words_progress_rejected[salt_pos];
 855     all_restored += data.words_progress_restored[salt_pos];
 856   }
 857
 858   u64 progress_cur = all_restored + all_done + all_rejected;
 859   u64 progress_end = progress_total;
 860
 861   u64 progress_skip = 0;
 862
 863   if (data.skip)
 864   {
 865     progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
 866
 867     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
 868     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_skip *= data.combs_cnt;
 869     else if (data.attack_kern == ATTACK_KERN_BF)       progress_skip *= data.bfs_cnt;
 870   }
 871
 872   if (data.limit)
 873   {
 874     progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
 875
 876     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end  *= data.kernel_rules_cnt;
 877     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_end  *= data.combs_cnt;
 878     else if (data.attack_kern == ATTACK_KERN_BF)       progress_end  *= data.bfs_cnt;
 879   }
 880
 881   u64 progress_cur_relative_skip = progress_cur - progress_skip;
 882   u64 progress_end_relative_skip = progress_end - progress_skip;
 883
 884   fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
 885
 886   /**
 887    * cracks
 888    */
 889
 890   fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
 891   fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done,   data.salts_cnt);
 892
 893   /**
 894    * temperature
 895    */
 896
 897   #ifdef HAVE_HWMON
 898   if (data.gpu_temp_disable == 0)
 899   {
 900     fprintf (out, "TEMP\t");
 901
 902     hc_thread_mutex_lock (mux_adl);
 903
 904     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
 905     {
 906       hc_device_param_t *device_param = &data.devices_param[device_id];
 907
 908       if (device_param->skipped) continue;
 909
 910       int temp = hm_get_temperature_with_device_id (device_id);
 911
 912       fprintf (out, "%d\t", temp);
 913     }
 914
 915     hc_thread_mutex_unlock (mux_adl);
 916   }
 917   #endif // HAVE_HWMON
 918
 919   /**
 920    * flush
 921    */
 922
 923   fputs (EOL, out);
 924   fflush (out);
 925 }
 926
 927 void status_display ()
 928 {
 929   if (data.devices_status == STATUS_INIT)     return;
 930   if (data.devices_status == STATUS_STARTING) return;
 931
 932   // in this case some required buffers are free'd, ascii_digest() would run into segfault
 933   if (data.shutdown_inner == 1) return;
 934
 935   if (data.machine_readable == 1)
 936   {
 937     status_display_machine_readable ();
 938
 939     return;
 940   }
 941
 942   char tmp_buf[1000] = { 0 };
 943
 944   uint tmp_len = 0;
 945
 946   log_info ("Session.Name...: %s", data.session);
 947
 948   char *status_type = strstatus (data.devices_status);
 949
 950   uint hash_mode = data.hash_mode;
 951
 952   char *hash_type = strhashtype (hash_mode); // not a bug
 953
 954   log_info ("Status.........: %s", status_type);
 955
 956   /**
 957    * show rules
 958    */
 959
 960   if (data.rp_files_cnt)
 961   {
 962     uint i;
 963
 964     for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
 965     {
 966       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
 967     }
 968
 969     snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
 970
 971     log_info ("Rules.Type.....: %s", tmp_buf);
 972
 973     tmp_len = 0;
 974   }
 975
 976   if (data.rp_gen)
 977   {
 978     log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
 979
 980     if (data.rp_gen_seed)
 981     {
 982       log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
 983     }
 984   }
 985
 986   /**
 987    * show input
 988    */
 989
 990   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
 991   {
 992     if (data.wordlist_mode == WL_MODE_FILE)
 993     {
 994       if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
 995     }
 996     else if (data.wordlist_mode == WL_MODE_STDIN)
 997     {
 998       log_info ("Input.Mode.....: Pipe");
 999     }
1000   }
1001   else if (data.attack_mode == ATTACK_MODE_COMBI)
1002   {
1003     if (data.dictfile  != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1004     if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1005   }
1006   else if (data.attack_mode == ATTACK_MODE_BF)
1007   {
1008     char *mask = data.mask;
1009
1010     if (mask != NULL)
1011     {
1012       uint mask_len = data.css_cnt;
1013
1014       tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1015
1016       if (mask_len > 0)
1017       {
1018         if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1019         {
1020           if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1021           {
1022             mask_len -= data.salts_buf[0].salt_len;
1023           }
1024         }
1025
1026         if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1027
1028         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1029       }
1030
1031       if (data.maskcnt > 1)
1032       {
1033         float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1034
1035         tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1036       }
1037
1038       log_info ("Input.Mode.....: %s", tmp_buf);
1039     }
1040
1041     tmp_len = 0;
1042   }
1043   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1044   {
1045     if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1046     if (data.mask     != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047   }
1048   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1049   {
1050     if (data.mask     != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051     if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1052   }
1053
1054   if (data.digests_cnt == 1)
1055   {
1056     if (data.hash_mode == 2500)
1057     {
1058       wpa_t *wpa = (wpa_t *) data.esalts_buf;
1059
1060       log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1061                 (char *) data.salts_buf[0].salt_buf,
1062                 wpa->orig_mac1[0],
1063                 wpa->orig_mac1[1],
1064                 wpa->orig_mac1[2],
1065                 wpa->orig_mac1[3],
1066                 wpa->orig_mac1[4],
1067                 wpa->orig_mac1[5],
1068                 wpa->orig_mac2[0],
1069                 wpa->orig_mac2[1],
1070                 wpa->orig_mac2[2],
1071                 wpa->orig_mac2[3],
1072                 wpa->orig_mac2[4],
1073                 wpa->orig_mac2[5]);
1074     }
1075     else if (data.hash_mode == 5200)
1076     {
1077       log_info ("Hash.Target....: File (%s)", data.hashfile);
1078     }
1079     else if (data.hash_mode == 9000)
1080     {
1081       log_info ("Hash.Target....: File (%s)", data.hashfile);
1082     }
1083     else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1084     {
1085       log_info ("Hash.Target....: File (%s)", data.hashfile);
1086     }
1087     else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1088     {
1089       log_info ("Hash.Target....: File (%s)", data.hashfile);
1090     }
1091     else
1092     {
1093       char out_buf[HCBUFSIZ] = { 0 };
1094
1095       ascii_digest (out_buf, 0, 0);
1096
1097       // limit length
1098       if (strlen (out_buf) > 40)
1099       {
1100         out_buf[41] = '.';
1101         out_buf[42] = '.';
1102         out_buf[43] = '.';
1103         out_buf[44] = 0;
1104       }
1105
1106       log_info ("Hash.Target....: %s", out_buf);
1107     }
1108   }
1109   else
1110   {
1111     if (data.hash_mode == 3000)
1112     {
1113       char out_buf1[32] = { 0 };
1114       char out_buf2[32] = { 0 };
1115
1116       ascii_digest (out_buf1, 0, 0);
1117       ascii_digest (out_buf2, 0, 1);
1118
1119       log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120     }
1121     else
1122     {
1123       log_info ("Hash.Target....: File (%s)", data.hashfile);
1124     }
1125   }
1126
1127   log_info ("Hash.Type......: %s", hash_type);
1128
1129   /**
1130    * speed new
1131    */
1132
1133   u64    speed_cnt[DEVICES_MAX] = { 0 };
1134   double speed_ms[DEVICES_MAX]  = { 0 };
1135
1136   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137   {
1138     hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140     if (device_param->skipped) continue;
1141
1142     speed_cnt[device_id] = 0;
1143     speed_ms[device_id]  = 0;
1144
1145     for (int i = 0; i < SPEED_CACHE; i++)
1146     {
1147       speed_cnt[device_id] += device_param->speed_cnt[i];
1148       speed_ms[device_id]  += device_param->speed_ms[i];
1149     }
1150
1151     speed_cnt[device_id] /= SPEED_CACHE;
1152     speed_ms[device_id]  /= SPEED_CACHE;
1153   }
1154
1155   double hashes_all_ms = 0;
1156
1157   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1158
1159   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1160   {
1161     hc_device_param_t *device_param = &data.devices_param[device_id];
1162
1163     if (device_param->skipped) continue;
1164
1165     hashes_dev_ms[device_id] = 0;
1166
1167     if (speed_ms[device_id])
1168     {
1169       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1170
1171       hashes_all_ms += hashes_dev_ms[device_id];
1172     }
1173   }
1174
1175   /**
1176    * exec time
1177    */
1178
1179   double exec_all_ms[DEVICES_MAX] = { 0 };
1180
1181   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1182   {
1183     hc_device_param_t *device_param = &data.devices_param[device_id];
1184
1185     if (device_param->skipped) continue;
1186
1187     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1188
1189     exec_all_ms[device_id] = exec_ms_avg;
1190   }
1191
1192   /**
1193    * timers
1194    */
1195
1196   double ms_running = 0;
1197
1198   hc_timer_get (data.timer_running, ms_running);
1199
1200   double ms_paused = data.ms_paused;
1201
1202   if (data.devices_status == STATUS_PAUSED)
1203   {
1204     double ms_paused_tmp = 0;
1205
1206     hc_timer_get (data.timer_paused, ms_paused_tmp);
1207
1208     ms_paused += ms_paused_tmp;
1209   }
1210
1211   #ifdef WIN
1212
1213   __time64_t sec_run = ms_running / 1000;
1214
1215   #else
1216
1217   time_t sec_run = ms_running / 1000;
1218
1219   #endif
1220
1221   if (sec_run)
1222   {
1223     char display_run[32] = { 0 };
1224
1225     struct tm tm_run;
1226
1227     struct tm *tmp = NULL;
1228
1229     #ifdef WIN
1230
1231     tmp = _gmtime64 (&sec_run);
1232
1233     #else
1234
1235     tmp = gmtime (&sec_run);
1236
1237     #endif
1238
1239     if (tmp != NULL)
1240     {
1241       memset (&tm_run, 0, sizeof (tm_run));
1242
1243       memcpy (&tm_run, tmp, sizeof (tm_run));
1244
1245       format_timer_display (&tm_run, display_run, sizeof (tm_run));
1246
1247       char *start = ctime (&data.proc_start);
1248
1249       size_t start_len = strlen (start);
1250
1251       if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1252       if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1253
1254       log_info ("Time.Started...: %s (%s)", start, display_run);
1255     }
1256   }
1257   else
1258   {
1259     log_info ("Time.Started...: 0 secs");
1260   }
1261
1262   /**
1263    * counters
1264    */
1265
1266   u64 progress_total = data.words_cnt * data.salts_cnt;
1267
1268   u64 all_done     = 0;
1269   u64 all_rejected = 0;
1270   u64 all_restored = 0;
1271
1272   u64 progress_noneed = 0;
1273
1274   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1275   {
1276     all_done     += data.words_progress_done[salt_pos];
1277     all_rejected += data.words_progress_rejected[salt_pos];
1278     all_restored += data.words_progress_restored[salt_pos];
1279
1280     // Important for ETA only
1281
1282     if (data.salts_shown[salt_pos] == 1)
1283     {
1284       const u64 all = data.words_progress_done[salt_pos]
1285                     + data.words_progress_rejected[salt_pos]
1286                     + data.words_progress_restored[salt_pos];
1287
1288       const u64 left = data.words_cnt - all;
1289
1290       progress_noneed += left;
1291     }
1292   }
1293
1294   u64 progress_cur = all_restored + all_done + all_rejected;
1295   u64 progress_end = progress_total;
1296
1297   u64 progress_skip = 0;
1298
1299   if (data.skip)
1300   {
1301     progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1302
1303     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1304     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_skip *= data.combs_cnt;
1305     else if (data.attack_kern == ATTACK_KERN_BF)       progress_skip *= data.bfs_cnt;
1306   }
1307
1308   if (data.limit)
1309   {
1310     progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1311
1312     if      (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end  *= data.kernel_rules_cnt;
1313     else if (data.attack_kern == ATTACK_KERN_COMBI)    progress_end  *= data.combs_cnt;
1314     else if (data.attack_kern == ATTACK_KERN_BF)       progress_end  *= data.bfs_cnt;
1315   }
1316
1317   u64 progress_cur_relative_skip = progress_cur - progress_skip;
1318   u64 progress_end_relative_skip = progress_end - progress_skip;
1319
1320   if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1321   {
1322     if (data.devices_status != STATUS_CRACKED)
1323     {
1324       #ifdef WIN
1325       __time64_t sec_etc = 0;
1326       #else
1327       time_t sec_etc = 0;
1328       #endif
1329
1330       if (hashes_all_ms)
1331       {
1332         u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1333
1334         u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1335
1336         sec_etc = ms_left / 1000;
1337       }
1338
1339       if (sec_etc == 0)
1340       {
1341         //log_info ("Time.Estimated.: 0 secs");
1342       }
1343       else if ((u64) sec_etc > ETC_MAX)
1344       {
1345         log_info ("Time.Estimated.: > 10 Years");
1346       }
1347       else
1348       {
1349         char display_etc[32]     = { 0 };
1350         char display_runtime[32] = { 0 };
1351
1352         struct tm tm_etc;
1353         struct tm tm_runtime;
1354
1355         struct tm *tmp = NULL;
1356
1357         #ifdef WIN
1358         tmp = _gmtime64 (&sec_etc);
1359         #else
1360         tmp = gmtime (&sec_etc);
1361         #endif
1362
1363         if (tmp != NULL)
1364         {
1365           memcpy (&tm_etc, tmp, sizeof (tm_etc));
1366
1367           format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1368
1369           time_t now;
1370
1371           time (&now);
1372
1373           now += sec_etc;
1374
1375           char *etc = ctime (&now);
1376
1377           size_t etc_len = strlen (etc);
1378
1379           if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1380           if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1381
1382           if (data.runtime)
1383           {
1384             time_t runtime_cur;
1385
1386             time (&runtime_cur);
1387
1388             #ifdef WIN
1389
1390             __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1391
1392             tmp = _gmtime64 (&runtime_left);
1393
1394             #else
1395
1396             time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1397
1398             tmp = gmtime (&runtime_left);
1399
1400             #endif
1401
1402             if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1403             {
1404               memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1405
1406               format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1407
1408               log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1409             }
1410             else
1411             {
1412               log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1413             }
1414           }
1415           else
1416           {
1417             log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1418           }
1419         }
1420       }
1421     }
1422   }
1423
1424   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1425   {
1426     hc_device_param_t *device_param = &data.devices_param[device_id];
1427
1428     if (device_param->skipped) continue;
1429
1430     char display_dev_cur[16] = { 0 };
1431
1432     strncpy (display_dev_cur, "0.00", 4);
1433
1434     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1435
1436     log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1437   }
1438
1439   char display_all_cur[16] = { 0 };
1440
1441   strncpy (display_all_cur, "0.00", 4);
1442
1443   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1444
1445   if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1446
1447   const float digests_percent = (float) data.digests_done / data.digests_cnt;
1448   const float salts_percent   = (float) data.salts_done   / data.salts_cnt;
1449
1450   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);
1451
1452   // crack-per-time
1453
1454   if (data.digests_cnt > 100)
1455   {
1456     time_t now = time (NULL);
1457
1458     int cpt_cur_min  = 0;
1459     int cpt_cur_hour = 0;
1460     int cpt_cur_day  = 0;
1461
1462     for (int i = 0; i < CPT_BUF; i++)
1463     {
1464       const uint   cracked   = data.cpt_buf[i].cracked;
1465       const time_t timestamp = data.cpt_buf[i].timestamp;
1466
1467       if ((timestamp + 60) > now)
1468       {
1469         cpt_cur_min  += cracked;
1470       }
1471
1472       if ((timestamp + 3600) > now)
1473       {
1474         cpt_cur_hour += cracked;
1475       }
1476
1477       if ((timestamp + 86400) > now)
1478       {
1479         cpt_cur_day  += cracked;
1480       }
1481     }
1482
1483     double ms_real = ms_running - ms_paused;
1484
1485     float cpt_avg_min  = (float) data.cpt_total / ((ms_real / 1000) / 60);
1486     float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1487     float cpt_avg_day  = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1488
1489     if ((data.cpt_start + 86400) < now)
1490     {
1491       log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1492         cpt_cur_min,
1493         cpt_cur_hour,
1494         cpt_cur_day,
1495         cpt_avg_min,
1496         cpt_avg_hour,
1497         cpt_avg_day);
1498     }
1499     else if ((data.cpt_start + 3600) < now)
1500     {
1501       log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502         cpt_cur_min,
1503         cpt_cur_hour,
1504         cpt_avg_min,
1505         cpt_avg_hour,
1506         cpt_avg_day);
1507     }
1508     else if ((data.cpt_start + 60) < now)
1509     {
1510       log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1511         cpt_cur_min,
1512         cpt_avg_min,
1513         cpt_avg_hour,
1514         cpt_avg_day);
1515     }
1516     else
1517     {
1518       log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1519         cpt_avg_min,
1520         cpt_avg_hour,
1521         cpt_avg_day);
1522     }
1523   }
1524
1525   // Restore point
1526
1527   u64 restore_point = get_lowest_words_done ();
1528
1529   u64 restore_total = data.words_base;
1530
1531   float percent_restore = 0;
1532
1533   if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1534
1535   if (progress_end_relative_skip)
1536   {
1537     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538     {
1539       float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1540       float percent_rejected = 0.0;
1541
1542       if (progress_cur)
1543       {
1544         percent_rejected = (float) (all_rejected) / (float) progress_cur;
1545       }
1546
1547       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);
1548       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected,               (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1549
1550       if (data.restore_disable == 0)
1551       {
1552         if (percent_finished != 1)
1553         {
1554           log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1555         }
1556       }
1557     }
1558   }
1559   else
1560   {
1561     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1562     {
1563       log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1564       log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565
1566       if (data.restore_disable == 0)
1567       {
1568         log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1569       }
1570     }
1571     else
1572     {
1573       log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1574       log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1575
1576       // --restore not allowed if stdin is used -- really? why?
1577
1578       //if (data.restore_disable == 0)
1579       //{
1580       //  log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1581       //}
1582     }
1583   }
1584
1585   #ifdef HAVE_HWMON
1586
1587   if (data.devices_status == STATUS_EXHAUSTED)  return;
1588   if (data.devices_status == STATUS_CRACKED)    return;
1589   if (data.devices_status == STATUS_ABORTED)    return;
1590   if (data.devices_status == STATUS_QUIT)       return;
1591
1592   if (data.gpu_temp_disable == 0)
1593   {
1594     hc_thread_mutex_lock (mux_adl);
1595
1596     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597     {
1598       hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600       if (device_param->skipped) continue;
1601
1602       const int num_temperature = hm_get_temperature_with_device_id (device_id);
1603       const int num_fanspeed    = hm_get_fanspeed_with_device_id    (device_id);
1604       const int num_utilization = hm_get_utilization_with_device_id (device_id);
1605       const int num_corespeed   = hm_get_corespeed_with_device_id   (device_id);
1606       const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1607       const int num_buslanes    = hm_get_buslanes_with_device_id    (device_id);
1608       const int num_throttle    = hm_get_throttle_with_device_id    (device_id);
1609
1610       char output_buf[256] = { 0 };
1611
1612       int output_len = 0;
1613
1614       if (num_temperature >= 0)
1615       {
1616         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1617
1618         output_len = strlen (output_buf);
1619       }
1620
1621       if (num_fanspeed >= 0)
1622       {
1623         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1624
1625         output_len = strlen (output_buf);
1626       }
1627
1628       if (num_utilization >= 0)
1629       {
1630         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1631
1632         output_len = strlen (output_buf);
1633       }
1634
1635       if (num_corespeed >= 0)
1636       {
1637         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1638
1639         output_len = strlen (output_buf);
1640       }
1641
1642       if (num_memoryspeed >= 0)
1643       {
1644         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1645
1646         output_len = strlen (output_buf);
1647       }
1648
1649       if (num_buslanes >= 0)
1650       {
1651         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1652
1653         output_len = strlen (output_buf);
1654       }
1655
1656       if (num_throttle == 1)
1657       {
1658         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1659
1660         output_len = strlen (output_buf);
1661       }
1662
1663       if (output_len == 0)
1664       {
1665         snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1666
1667         output_len = strlen (output_buf);
1668       }
1669
1670       log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1671     }
1672
1673     hc_thread_mutex_unlock (mux_adl);
1674   }
1675
1676   #endif // HAVE_HWMON
1677 }
1678
1679 static void status_benchmark_automate ()
1680 {
1681   u64    speed_cnt[DEVICES_MAX] = { 0 };
1682   double speed_ms[DEVICES_MAX]  = { 0 };
1683
1684   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685   {
1686     hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688     if (device_param->skipped) continue;
1689
1690     speed_cnt[device_id] = device_param->speed_cnt[0];
1691     speed_ms[device_id]  = device_param->speed_ms[0];
1692   }
1693
1694   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1695
1696   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697   {
1698     hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700     if (device_param->skipped) continue;
1701
1702     hashes_dev_ms[device_id] = 0;
1703
1704     if (speed_ms[device_id])
1705     {
1706       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1707     }
1708   }
1709
1710   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1711   {
1712     hc_device_param_t *device_param = &data.devices_param[device_id];
1713
1714     if (device_param->skipped) continue;
1715
1716     log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1717   }
1718 }
1719
1720 static void status_benchmark ()
1721 {
1722   if (data.devices_status == STATUS_INIT)     return;
1723   if (data.devices_status == STATUS_STARTING) return;
1724
1725   if (data.shutdown_inner == 1) return;
1726
1727   if (data.machine_readable == 1)
1728   {
1729     status_benchmark_automate ();
1730
1731     return;
1732   }
1733
1734   u64    speed_cnt[DEVICES_MAX] = { 0 };
1735   double speed_ms[DEVICES_MAX]  = { 0 };
1736
1737   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738   {
1739     hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741     if (device_param->skipped) continue;
1742
1743     speed_cnt[device_id] = device_param->speed_cnt[0];
1744     speed_ms[device_id]  = device_param->speed_ms[0];
1745   }
1746
1747   double hashes_all_ms = 0;
1748
1749   double hashes_dev_ms[DEVICES_MAX] = { 0 };
1750
1751   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1752   {
1753     hc_device_param_t *device_param = &data.devices_param[device_id];
1754
1755     if (device_param->skipped) continue;
1756
1757     hashes_dev_ms[device_id] = 0;
1758
1759     if (speed_ms[device_id])
1760     {
1761       hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1762
1763       hashes_all_ms += hashes_dev_ms[device_id];
1764     }
1765   }
1766
1767   /**
1768    * exec time
1769    */
1770
1771   double exec_all_ms[DEVICES_MAX] = { 0 };
1772
1773   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1774   {
1775     hc_device_param_t *device_param = &data.devices_param[device_id];
1776
1777     if (device_param->skipped) continue;
1778
1779     double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1780
1781     exec_all_ms[device_id] = exec_ms_avg;
1782   }
1783
1784   for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1785   {
1786     hc_device_param_t *device_param = &data.devices_param[device_id];
1787
1788     if (device_param->skipped) continue;
1789
1790     char display_dev_cur[16] = { 0 };
1791
1792     strncpy (display_dev_cur, "0.00", 4);
1793
1794     format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1795
1796     if (data.devices_active >= 10)
1797     {
1798       log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799     }
1800     else
1801     {
1802       log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1803     }
1804   }
1805
1806   char display_all_cur[16] = { 0 };
1807
1808   strncpy (display_all_cur, "0.00", 4);
1809
1810   format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1811
1812   if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1813 }
1814
1815 /**
1816  * hashcat -only- functions
1817  */
1818
1819 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1820 {
1821   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1822   {
1823     if (attack_kern == ATTACK_KERN_STRAIGHT)
1824       snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1825     else if (attack_kern == ATTACK_KERN_COMBI)
1826       snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1827     else if (attack_kern == ATTACK_KERN_BF)
1828       snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1829   }
1830   else
1831     snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1832 }
1833
1834 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)
1835 {
1836   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1837   {
1838     if (attack_kern == ATTACK_KERN_STRAIGHT)
1839       snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840     else if (attack_kern == ATTACK_KERN_COMBI)
1841       snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1842     else if (attack_kern == ATTACK_KERN_BF)
1843       snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844   }
1845   else
1846   {
1847     snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1848   }
1849 }
1850
1851 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1852 {
1853   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1854   {
1855     snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1856   }
1857   else
1858   {
1859     snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1860   }
1861 }
1862
1863 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)
1864 {
1865   if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1866   {
1867     snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1868   }
1869   else
1870   {
1871     snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1872   }
1873 }
1874
1875 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1876 {
1877   snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1878 }
1879
1880 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1881 {
1882   snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1883 }
1884
1885 static char *filename_from_filepath (char *filepath)
1886 {
1887   char *ptr = NULL;
1888
1889   if ((ptr = strrchr (filepath, '/')) != NULL)
1890   {
1891     ptr++;
1892   }
1893   else if ((ptr = strrchr (filepath, '\\')) != NULL)
1894   {
1895     ptr++;
1896   }
1897   else
1898   {
1899     ptr = filepath;
1900   }
1901
1902   return ptr;
1903 }
1904
1905 static uint convert_from_hex (char *line_buf, const uint line_len)
1906 {
1907   if (line_len & 1) return (line_len); // not in hex
1908
1909   if (data.hex_wordlist == 1)
1910   {
1911     uint i;
1912     uint j;
1913
1914     for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1915     {
1916       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1917     }
1918
1919     memset (line_buf + i, 0, line_len - i);
1920
1921     return (i);
1922   }
1923   else if (line_len >= 6) // $HEX[] = 6
1924   {
1925     if (line_buf[0]            != '$') return (line_len);
1926     if (line_buf[1]            != 'H') return (line_len);
1927     if (line_buf[2]            != 'E') return (line_len);
1928     if (line_buf[3]            != 'X') return (line_len);
1929     if (line_buf[4]            != '[') return (line_len);
1930     if (line_buf[line_len - 1] != ']') return (line_len);
1931
1932     uint i;
1933     uint j;
1934
1935     for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1936     {
1937       line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1938     }
1939
1940     memset (line_buf + i, 0, line_len - i);
1941
1942     return (i);
1943   }
1944
1945   return (line_len);
1946 }
1947
1948 static void clear_prompt ()
1949 {
1950   fputc ('\r', stdout);
1951
1952   for (size_t i = 0; i < strlen (PROMPT); i++)
1953   {
1954     fputc (' ', stdout);
1955   }
1956
1957   fputc ('\r', stdout);
1958
1959   fflush (stdout);
1960 }
1961
1962 static int gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1963 {
1964   cl_int CL_err = 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);
1965
1966   if (CL_err != CL_SUCCESS)
1967   {
1968     log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
1969
1970     return -1;
1971   }
1972
1973   return 0;
1974 }
1975
1976 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1977 {
1978   char *outfile    = data.outfile;
1979   uint  quiet      = data.quiet;
1980   FILE *pot_fp     = data.pot_fp;
1981   uint  loopback   = data.loopback;
1982   uint  debug_mode = data.debug_mode;
1983   char *debug_file = data.debug_file;
1984
1985   char debug_rule_buf[BLOCK_SIZE] = { 0 };
1986   int  debug_rule_len  = 0; // -1 error
1987   uint debug_plain_len = 0;
1988
1989   u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1990
1991   // hash
1992
1993   char out_buf[HCBUFSIZ] = { 0 };
1994
1995   const u32 salt_pos    = plain->salt_pos;
1996   const u32 digest_pos  = plain->digest_pos;  // relative
1997   const u32 gidvid      = plain->gidvid;
1998   const u32 il_pos      = plain->il_pos;
1999
2000   ascii_digest (out_buf, salt_pos, digest_pos);
2001
2002   // plain
2003
2004   u64 crackpos = device_param->words_off;
2005
2006   uint plain_buf[16] = { 0 };
2007
2008   u8 *plain_ptr = (u8 *) plain_buf;
2009
2010   unsigned int plain_len = 0;
2011
2012   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2013   {
2014     pw_t pw;
2015
2016     gidd_to_pw_t (device_param, gidvid, &pw);
2017
2018     for (int i = 0; i < 16; i++)
2019     {
2020       plain_buf[i] = pw.i[i];
2021     }
2022
2023     plain_len = pw.pw_len;
2024
2025     const uint off = device_param->innerloop_pos + il_pos;
2026
2027     if (debug_mode > 0)
2028     {
2029       debug_rule_len = 0;
2030
2031       // save rule
2032       if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2033       {
2034         memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2035
2036         debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2037       }
2038
2039       // save plain
2040       if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2041       {
2042         memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2043
2044         memcpy (debug_plain_ptr, plain_ptr, plain_len);
2045
2046         debug_plain_len = plain_len;
2047       }
2048     }
2049
2050     plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2051
2052     crackpos += gidvid;
2053     crackpos *= data.kernel_rules_cnt;
2054     crackpos += device_param->innerloop_pos + il_pos;
2055
2056     if (plain_len > data.pw_max) plain_len = data.pw_max;
2057   }
2058   else if (data.attack_mode == ATTACK_MODE_COMBI)
2059   {
2060     pw_t pw;
2061
2062     gidd_to_pw_t (device_param, gidvid, &pw);
2063
2064     for (int i = 0; i < 16; i++)
2065     {
2066       plain_buf[i] = pw.i[i];
2067     }
2068
2069     plain_len = pw.pw_len;
2070
2071     char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2072     uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2073
2074     if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2075     {
2076       memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2077     }
2078     else
2079     {
2080       memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2081
2082       memcpy (plain_ptr, comb_buf, comb_len);
2083     }
2084
2085     plain_len += comb_len;
2086
2087     crackpos += gidvid;
2088     crackpos *= data.combs_cnt;
2089     crackpos += device_param->innerloop_pos + il_pos;
2090
2091     if (data.pw_max != PW_DICTMAX1)
2092     {
2093       if (plain_len > data.pw_max) plain_len = data.pw_max;
2094     }
2095   }
2096   else if (data.attack_mode == ATTACK_MODE_BF)
2097   {
2098     u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2099     u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2100
2101     uint l_start = device_param->kernel_params_mp_l_buf32[5];
2102     uint r_start = device_param->kernel_params_mp_r_buf32[5];
2103
2104     uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2105     uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2106
2107     sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2108     sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2109
2110     plain_len = data.css_cnt;
2111
2112     crackpos += gidvid;
2113     crackpos *= data.bfs_cnt;
2114     crackpos += device_param->innerloop_pos + il_pos;
2115   }
2116   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2117   {
2118     pw_t pw;
2119
2120     gidd_to_pw_t (device_param, gidvid, &pw);
2121
2122     for (int i = 0; i < 16; i++)
2123     {
2124       plain_buf[i] = pw.i[i];
2125     }
2126
2127     plain_len = pw.pw_len;
2128
2129     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2130
2131     uint start = 0;
2132     uint stop  = device_param->kernel_params_mp_buf32[4];
2133
2134     sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2135
2136     plain_len += start + stop;
2137
2138     crackpos += gidvid;
2139     crackpos *= data.combs_cnt;
2140     crackpos += device_param->innerloop_pos + il_pos;
2141
2142     if (data.pw_max != PW_DICTMAX1)
2143     {
2144       if (plain_len > data.pw_max) plain_len = data.pw_max;
2145     }
2146   }
2147   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2148   {
2149     pw_t pw;
2150
2151     gidd_to_pw_t (device_param, gidvid, &pw);
2152
2153     for (int i = 0; i < 16; i++)
2154     {
2155       plain_buf[i] = pw.i[i];
2156     }
2157
2158     plain_len = pw.pw_len;
2159
2160     u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2161
2162     uint start = 0;
2163     uint stop  = device_param->kernel_params_mp_buf32[4];
2164
2165     memmove (plain_ptr + stop, plain_ptr, plain_len);
2166
2167     sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2168
2169     plain_len += start + stop;
2170
2171     crackpos += gidvid;
2172     crackpos *= data.combs_cnt;
2173     crackpos += device_param->innerloop_pos + il_pos;
2174
2175     if (data.pw_max != PW_DICTMAX1)
2176     {
2177       if (plain_len > data.pw_max) plain_len = data.pw_max;
2178     }
2179   }
2180
2181   if (data.attack_mode == ATTACK_MODE_BF)
2182   {
2183     if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2184     {
2185       if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2186       {
2187         if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2188         {
2189           plain_len = plain_len - data.salts_buf[0].salt_len;
2190         }
2191       }
2192
2193       if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2194       {
2195         for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2196         {
2197           plain_ptr[j] = plain_ptr[i];
2198         }
2199
2200         plain_len = plain_len / 2;
2201       }
2202     }
2203   }
2204
2205   // if enabled, update also the potfile
2206
2207   if (pot_fp)
2208   {
2209     lock_file (pot_fp);
2210
2211     fprintf (pot_fp, "%s:", out_buf);
2212
2213     format_plain (pot_fp, plain_ptr, plain_len, 1);
2214
2215     fputc ('\n', pot_fp);
2216
2217     fflush (pot_fp);
2218
2219     unlock_file (pot_fp);
2220   }
2221
2222   // outfile
2223
2224   FILE *out_fp = NULL;
2225
2226   if (outfile != NULL)
2227   {
2228     if ((out_fp = fopen (outfile, "ab")) == NULL)
2229     {
2230       log_error ("ERROR: %s: %s", outfile, strerror (errno));
2231
2232       out_fp = stdout;
2233     }
2234
2235     lock_file (out_fp);
2236   }
2237   else
2238   {
2239     out_fp = stdout;
2240
2241     if (quiet == 0) clear_prompt ();
2242   }
2243
2244   format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2245
2246   if (outfile != NULL)
2247   {
2248     if (out_fp != stdout)
2249     {
2250       fclose (out_fp);
2251     }
2252   }
2253   else
2254   {
2255     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2256     {
2257       if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2258       {
2259         if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2260         if (quiet == 0) fflush (stdout);
2261       }
2262     }
2263   }
2264
2265   // loopback
2266
2267   if (loopback)
2268   {
2269     char *loopback_file = data.loopback_file;
2270
2271     FILE *fb_fp = NULL;
2272
2273     if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2274     {
2275       lock_file (fb_fp);
2276
2277       format_plain (fb_fp, plain_ptr, plain_len, 1);
2278
2279       fputc ('\n', fb_fp);
2280
2281       fclose (fb_fp);
2282     }
2283   }
2284
2285   // (rule) debug mode
2286
2287   // the next check implies that:
2288   // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2289   // - debug_mode > 0
2290
2291   if ((debug_plain_len > 0) || (debug_rule_len > 0))
2292   {
2293     if (debug_rule_len < 0) debug_rule_len = 0;
2294
2295     if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2296
2297     format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2298
2299     if ((quiet == 0) && (debug_file == NULL))
2300     {
2301       fprintf (stdout, "%s", PROMPT);
2302
2303       fflush (stdout);
2304     }
2305   }
2306 }
2307
2308 static int check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2309 {
2310   salt_t *salt_buf = &data.salts_buf[salt_pos];
2311
2312   u32 num_cracked;
2313
2314   cl_int CL_err;
2315
2316   CL_err = hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2317
2318   if (CL_err != CL_SUCCESS)
2319   {
2320     log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
2321
2322     return -1;
2323   }
2324
2325   if (num_cracked)
2326   {
2327     // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2328
2329     log_info_nn ("");
2330
2331     plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2332
2333     CL_err = 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);
2334
2335     if (CL_err != CL_SUCCESS)
2336     {
2337       log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
2338
2339       return -1;
2340     }
2341
2342     uint cpt_cracked = 0;
2343
2344     hc_thread_mutex_lock (mux_display);
2345
2346     for (uint i = 0; i < num_cracked; i++)
2347     {
2348       const uint hash_pos = cracked[i].hash_pos;
2349
2350       if (data.digests_shown[hash_pos] == 1) continue;
2351
2352       if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2353       {
2354         data.digests_shown[hash_pos] = 1;
2355
2356         data.digests_done++;
2357
2358         cpt_cracked++;
2359
2360         salt_buf->digests_done++;
2361
2362         if (salt_buf->digests_done == salt_buf->digests_cnt)
2363         {
2364           data.salts_shown[salt_pos] = 1;
2365
2366           data.salts_done++;
2367         }
2368       }
2369
2370       if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2371
2372       check_hash (device_param, &cracked[i]);
2373     }
2374
2375     hc_thread_mutex_unlock (mux_display);
2376
2377     myfree (cracked);
2378
2379     if (cpt_cracked > 0)
2380     {
2381       hc_thread_mutex_lock (mux_display);
2382
2383       data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2384       data.cpt_buf[data.cpt_pos].cracked   = cpt_cracked;
2385
2386       data.cpt_pos++;
2387
2388       data.cpt_total += cpt_cracked;
2389
2390       if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2391
2392       hc_thread_mutex_unlock (mux_display);
2393     }
2394
2395     if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2396     {
2397       // we need to reset cracked state on the device
2398       // otherwise host thinks again and again the hash was cracked
2399       // and returns invalid password each time
2400
2401       memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2402
2403       CL_err = 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);
2404
2405       if (CL_err != CL_SUCCESS)
2406       {
2407         log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
2408
2409         return -1;
2410       }
2411     }
2412
2413     num_cracked = 0;
2414
2415     CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2416
2417     if (CL_err != CL_SUCCESS)
2418     {
2419       log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
2420
2421       return -1;
2422     }
2423   }
2424
2425   return 0;
2426 }
2427
2428 // stolen from princeprocessor ;)
2429
2430 typedef struct
2431 {
2432   FILE *fp;
2433
2434   char  buf[BUFSIZ];
2435   int   len;
2436
2437 } out_t;
2438
2439 static void out_flush (out_t *out)
2440 {
2441   fwrite (out->buf, 1, out->len, out->fp);
2442
2443   out->len = 0;
2444 }
2445
2446 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2447 {
2448   char *ptr = out->buf + out->len;
2449
2450   memcpy (ptr, pw_buf, pw_len);
2451
2452   ptr[pw_len] = '\n';
2453
2454   out->len += pw_len + 1;
2455
2456   if (out->len >= BUFSIZ - 100)
2457   {
2458     out_flush (out);
2459   }
2460 }
2461
2462 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2463 {
2464   out_t out;
2465
2466   out.fp  = stdout;
2467   out.len = 0;
2468
2469   uint plain_buf[16] = { 0 };
2470
2471   u8 *plain_ptr = (u8 *) plain_buf;
2472
2473   uint plain_len = 0;
2474
2475   const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2476
2477   if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2478   {
2479     pw_t pw;
2480
2481     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2482     {
2483       gidd_to_pw_t (device_param, gidvid, &pw);
2484
2485       const uint pos = device_param->innerloop_pos;
2486
2487       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2488       {
2489         for (int i = 0; i < 8; i++)
2490         {
2491           plain_buf[i] = pw.i[i];
2492         }
2493
2494         plain_len = pw.pw_len;
2495
2496         plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2497
2498         if (plain_len > data.pw_max) plain_len = data.pw_max;
2499
2500         out_push (&out, plain_ptr, plain_len);
2501       }
2502     }
2503   }
2504   else if (data.attack_mode == ATTACK_MODE_COMBI)
2505   {
2506     pw_t pw;
2507
2508     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2509     {
2510       gidd_to_pw_t (device_param, gidvid, &pw);
2511
2512       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2513       {
2514         for (int i = 0; i < 8; i++)
2515         {
2516           plain_buf[i] = pw.i[i];
2517         }
2518
2519         plain_len = pw.pw_len;
2520
2521         char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2522         uint  comb_len =          device_param->combs_buf[il_pos].pw_len;
2523
2524         if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2525         {
2526           memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2527         }
2528         else
2529         {
2530           memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2531
2532           memcpy (plain_ptr, comb_buf, comb_len);
2533         }
2534
2535         plain_len += comb_len;
2536
2537         if (data.pw_max != PW_DICTMAX1)
2538         {
2539           if (plain_len > data.pw_max) plain_len = data.pw_max;
2540         }
2541
2542         out_push (&out, plain_ptr, plain_len);
2543       }
2544     }
2545   }
2546   else if (data.attack_mode == ATTACK_MODE_BF)
2547   {
2548     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2549     {
2550       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2551       {
2552         u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2553         u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2554
2555         uint l_start = device_param->kernel_params_mp_l_buf32[5];
2556         uint r_start = device_param->kernel_params_mp_r_buf32[5];
2557
2558         uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2559         uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2560
2561         sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2562         sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2563
2564         plain_len = data.css_cnt;
2565
2566         out_push (&out, plain_ptr, plain_len);
2567       }
2568     }
2569   }
2570   else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2571   {
2572     pw_t pw;
2573
2574     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2575     {
2576       gidd_to_pw_t (device_param, gidvid, &pw);
2577
2578       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2579       {
2580         for (int i = 0; i < 8; i++)
2581         {
2582           plain_buf[i] = pw.i[i];
2583         }
2584
2585         plain_len = pw.pw_len;
2586
2587         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2588
2589         uint start = 0;
2590         uint stop  = device_param->kernel_params_mp_buf32[4];
2591
2592         sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2593
2594         plain_len += start + stop;
2595
2596         out_push (&out, plain_ptr, plain_len);
2597       }
2598     }
2599   }
2600   else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2601   {
2602     pw_t pw;
2603
2604     for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2605     {
2606       gidd_to_pw_t (device_param, gidvid, &pw);
2607
2608       for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2609       {
2610         for (int i = 0; i < 8; i++)
2611         {
2612           plain_buf[i] = pw.i[i];
2613         }
2614
2615         plain_len = pw.pw_len;
2616
2617         u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2618
2619         uint start = 0;
2620         uint stop  = device_param->kernel_params_mp_buf32[4];
2621
2622         memmove (plain_ptr + stop, plain_ptr, plain_len);
2623
2624         sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2625
2626         plain_len += start + stop;
2627
2628         out_push (&out, plain_ptr, plain_len);
2629       }
2630     }
2631   }
2632
2633   out_flush (&out);
2634 }
2635
2636 static void save_hash ()
2637 {
2638   char *hashfile = data.hashfile;
2639
2640   char new_hashfile[256] = { 0 };
2641   char old_hashfile[256] = { 0 };
2642
2643   snprintf (new_hashfile, 255, "%s.new", hashfile);
2644   snprintf (old_hashfile, 255, "%s.old", hashfile);
2645
2646   unlink (new_hashfile);
2647
2648   char separator = data.separator;
2649
2650   FILE *fp = fopen (new_hashfile, "wb");
2651
2652   if (fp == NULL)
2653   {
2654     log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2655
2656     exit (-1);
2657   }
2658
2659   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2660   {
2661     if (data.salts_shown[salt_pos] == 1) continue;
2662
2663     salt_t *salt_buf = &data.salts_buf[salt_pos];
2664
2665     for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2666     {
2667       uint idx = salt_buf->digests_offset + digest_pos;
2668
2669       if (data.digests_shown[idx] == 1) continue;
2670
2671       if (data.hash_mode != 2500)
2672       {
2673         if (data.username == 1)
2674         {
2675           user_t *user = data.hash_info[idx]->user;
2676
2677           uint i;
2678
2679           for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2680
2681           fputc (separator, fp);
2682         }
2683
2684         char out_buf[HCBUFSIZ]; // scratch buffer
2685
2686         out_buf[0] = 0;
2687
2688         ascii_digest (out_buf, salt_pos, digest_pos);
2689
2690         fputs (out_buf, fp);
2691
2692         fputc ('\n', fp);
2693       }
2694       else
2695       {
2696         hccap_t hccap;
2697
2698         to_hccap_t (&hccap, salt_pos, digest_pos);
2699
2700         fwrite (&hccap, sizeof (hccap_t), 1, fp);
2701       }
2702     }
2703   }
2704
2705   fflush (fp);
2706
2707   fclose (fp);
2708
2709   unlink (old_hashfile);
2710
2711   if (rename (hashfile, old_hashfile) != 0)
2712   {
2713     log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2714
2715     exit (-1);
2716   }
2717
2718   unlink (hashfile);
2719
2720   if (rename (new_hashfile, hashfile) != 0)
2721   {
2722     log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2723
2724     exit (-1);
2725   }
2726
2727   unlink (old_hashfile);
2728 }
2729
2730 static int run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2731 {
2732   cl_int CL_err = CL_SUCCESS;
2733
2734   uint num_elements = num;
2735
2736   device_param->kernel_params_buf32[33] = data.combs_mode;
2737   device_param->kernel_params_buf32[34] = num;
2738
2739   uint kernel_threads = device_param->kernel_threads;
2740
2741   while (num_elements % kernel_threads) num_elements++;
2742
2743   cl_kernel kernel = NULL;
2744
2745   switch (kern_run)
2746   {
2747     case KERN_RUN_1:    kernel = device_param->kernel1;     break;
2748     case KERN_RUN_12:   kernel = device_param->kernel12;    break;
2749     case KERN_RUN_2:    kernel = device_param->kernel2;     break;
2750     case KERN_RUN_23:   kernel = device_param->kernel23;    break;
2751     case KERN_RUN_3:    kernel = device_param->kernel3;     break;
2752   }
2753
2754   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2755   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2756   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2757   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2758   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2759   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2760   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2761   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2762   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2763   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2764   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2765
2766   if (CL_err != CL_SUCCESS)
2767   {
2768     log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
2769
2770     return -1;
2771   }
2772
2773   cl_event event;
2774
2775   if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2776   {
2777     const size_t global_work_size[3] = { num_elements,        32, 1 };
2778     const size_t local_work_size[3]  = { kernel_threads / 32, 32, 1 };
2779
2780     CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2781
2782     if (CL_err != CL_SUCCESS)
2783     {
2784       log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2785
2786       return -1;
2787     }
2788   }
2789   else
2790   {
2791     if (kern_run == KERN_RUN_2)
2792     {
2793       if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2794       {
2795         num_elements = CEIL ((float) num_elements / device_param->vector_width);
2796       }
2797     }
2798
2799     while (num_elements % kernel_threads) num_elements++;
2800
2801     const size_t global_work_size[3] = { num_elements,   1, 1 };
2802     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2803
2804     CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2805
2806     if (CL_err != CL_SUCCESS)
2807     {
2808       log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2809
2810       return -1;
2811     }
2812   }
2813
2814   CL_err = hc_clFlush (data.ocl, device_param->command_queue);
2815
2816   if (CL_err != CL_SUCCESS)
2817   {
2818     log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
2819
2820     return -1;
2821   }
2822
2823   if (device_param->nvidia_spin_damp)
2824   {
2825     if (data.devices_status == STATUS_RUNNING)
2826     {
2827       if (iteration < EXPECTED_ITERATIONS)
2828       {
2829         switch (kern_run)
2830         {
2831           case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2832           case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2833           case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2834         }
2835       }
2836     }
2837   }
2838
2839   CL_err = hc_clWaitForEvents (data.ocl, 1, &event);
2840
2841   if (CL_err != CL_SUCCESS)
2842   {
2843     log_error ("ERROR: clWaitForEvents(): %s\n", val2cstr_cl (CL_err));
2844
2845     return -1;
2846   }
2847
2848   cl_ulong time_start;
2849   cl_ulong time_end;
2850
2851   CL_err |= hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2852   CL_err |= hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END,   sizeof (time_end),   &time_end,   NULL);
2853
2854   if (CL_err != CL_SUCCESS)
2855   {
2856     log_error ("ERROR: clGetEventProfilingInfo(): %s\n", val2cstr_cl (CL_err));
2857
2858     return -1;
2859   }
2860
2861   const double exec_us = (double) (time_end - time_start) / 1000;
2862
2863   if (data.devices_status == STATUS_RUNNING)
2864   {
2865     if (iteration < EXPECTED_ITERATIONS)
2866     {
2867       switch (kern_run)
2868       {
2869         case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2870         case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2871         case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2872       }
2873     }
2874   }
2875
2876   if (event_update)
2877   {
2878     uint exec_pos = device_param->exec_pos;
2879
2880     device_param->exec_ms[exec_pos] = exec_us / 1000;
2881
2882     exec_pos++;
2883
2884     if (exec_pos == EXEC_CACHE)
2885     {
2886       exec_pos = 0;
2887     }
2888
2889     device_param->exec_pos = exec_pos;
2890   }
2891
2892   CL_err = hc_clReleaseEvent (data.ocl, event);
2893
2894   if (CL_err != CL_SUCCESS)
2895   {
2896     log_error ("ERROR: clReleaseEvent(): %s\n", val2cstr_cl (CL_err));
2897
2898     return -1;
2899   }
2900
2901   CL_err = hc_clFinish (data.ocl, device_param->command_queue);
2902
2903   if (CL_err != CL_SUCCESS)
2904   {
2905     log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
2906
2907     return -1;
2908   }
2909
2910   return 0;
2911 }
2912
2913 static int run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2914 {
2915   cl_int CL_err = CL_SUCCESS;
2916
2917   uint num_elements = num;
2918
2919   switch (kern_run)
2920   {
2921     case KERN_RUN_MP:   device_param->kernel_params_mp_buf32[8]   = num; break;
2922     case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2923     case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2924   }
2925
2926   // causes problems with special threads like in bcrypt
2927   // const uint kernel_threads = device_param->kernel_threads;
2928
2929   uint kernel_threads = device_param->kernel_threads;
2930
2931   while (num_elements % kernel_threads) num_elements++;
2932
2933   cl_kernel kernel = NULL;
2934
2935   switch (kern_run)
2936   {
2937     case KERN_RUN_MP:   kernel = device_param->kernel_mp;   break;
2938     case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2939     case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2940   }
2941
2942   switch (kern_run)
2943   {
2944     case KERN_RUN_MP:   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2945                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp[4]);
2946                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp[5]);
2947                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp[6]);
2948                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp[7]);
2949                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp[8]);
2950                         break;
2951     case KERN_RUN_MP_R: CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2952                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_r[4]);
2953                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_r[5]);
2954                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_r[6]);
2955                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_r[7]);
2956                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_r[8]);
2957                         break;
2958     case KERN_RUN_MP_L: CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2959                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint),  device_param->kernel_params_mp_l[4]);
2960                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint),  device_param->kernel_params_mp_l[5]);
2961                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint),  device_param->kernel_params_mp_l[6]);
2962                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint),  device_param->kernel_params_mp_l[7]);
2963                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint),  device_param->kernel_params_mp_l[8]);
2964                         CL_err |= hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint),  device_param->kernel_params_mp_l[9]);
2965                         break;
2966   }
2967
2968   if (CL_err != CL_SUCCESS)
2969   {
2970     log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
2971
2972     return -1;
2973   }
2974
2975   const size_t global_work_size[3] = { num_elements,   1, 1 };
2976   const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
2977
2978   CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2979
2980   if (CL_err != CL_SUCCESS)
2981   {
2982     log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2983
2984     return -1;
2985   }
2986
2987   CL_err = hc_clFlush (data.ocl, device_param->command_queue);
2988
2989   if (CL_err != CL_SUCCESS)
2990   {
2991     log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
2992
2993     return -1;
2994   }
2995
2996   CL_err = hc_clFinish (data.ocl, device_param->command_queue);
2997
2998   if (CL_err != CL_SUCCESS)
2999   {
3000     log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3001
3002     return -1;
3003   }
3004
3005   return 0;
3006 }
3007
3008 static int run_kernel_tm (hc_device_param_t *device_param)
3009 {
3010   cl_int CL_err = CL_SUCCESS;
3011
3012   const uint num_elements = 1024; // fixed
3013
3014   uint kernel_threads = 32;
3015
3016   cl_kernel kernel = device_param->kernel_tm;
3017
3018   const size_t global_work_size[3] = { num_elements,    1, 1 };
3019   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
3020
3021   CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3022
3023   if (CL_err != CL_SUCCESS)
3024   {
3025     log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3026
3027     return -1;
3028   }
3029
3030   CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3031
3032   if (CL_err != CL_SUCCESS)
3033   {
3034     log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3035
3036     return -1;
3037   }
3038
3039   CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3040
3041   if (CL_err != CL_SUCCESS)
3042   {
3043     log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3044
3045     return -1;
3046   }
3047
3048   return 0;
3049 }
3050
3051 static int run_kernel_amp (hc_device_param_t *device_param, const uint num)
3052 {
3053   cl_int CL_err = CL_SUCCESS;
3054
3055   uint num_elements = num;
3056
3057   device_param->kernel_params_amp_buf32[5] = data.combs_mode;
3058   device_param->kernel_params_amp_buf32[6] = num_elements;
3059
3060   // causes problems with special threads like in bcrypt
3061   // const uint kernel_threads = device_param->kernel_threads;
3062
3063   uint kernel_threads = device_param->kernel_threads;
3064
3065   while (num_elements % kernel_threads) num_elements++;
3066
3067   cl_kernel kernel = device_param->kernel_amp;
3068
3069   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
3070   CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
3071
3072   if (CL_err != CL_SUCCESS)
3073   {
3074     log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
3075
3076     return -1;
3077   }
3078
3079   const size_t global_work_size[3] = { num_elements,    1, 1 };
3080   const size_t local_work_size[3]  = { kernel_threads,  1, 1 };
3081
3082   CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3083
3084   if (CL_err != CL_SUCCESS)
3085   {
3086     log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3087
3088     return -1;
3089   }
3090
3091   CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3092
3093   if (CL_err != CL_SUCCESS)
3094   {
3095     log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3096
3097     return -1;
3098   }
3099
3100   CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3101
3102   if (CL_err != CL_SUCCESS)
3103   {
3104     log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3105
3106     return -1;
3107   }
3108
3109   return 0;
3110 }
3111
3112 static int run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
3113 {
3114   cl_int CL_err = CL_SUCCESS;
3115
3116   const u32 num16d = num / 16;
3117   const u32 num16m = num % 16;
3118
3119   if (num16d)
3120   {
3121     device_param->kernel_params_memset_buf32[1] = value;
3122     device_param->kernel_params_memset_buf32[2] = num16d;
3123
3124     uint kernel_threads = device_param->kernel_threads;
3125
3126     uint num_elements = num16d;
3127
3128     while (num_elements % kernel_threads) num_elements++;
3129
3130     cl_kernel kernel = device_param->kernel_memset;
3131
3132     CL_err |= hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem),  (void *) &buf);
3133     CL_err |= hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
3134     CL_err |= hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
3135
3136     if (CL_err != CL_SUCCESS)
3137     {
3138       log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
3139
3140       return -1;
3141     }
3142
3143     const size_t global_work_size[3] = { num_elements,   1, 1 };
3144     const size_t local_work_size[3]  = { kernel_threads, 1, 1 };
3145
3146     CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3147
3148     if (CL_err != CL_SUCCESS)
3149     {
3150       log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3151
3152       return -1;
3153     }
3154
3155     CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3156
3157     if (CL_err != CL_SUCCESS)
3158     {
3159       log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3160
3161       return -1;
3162     }
3163
3164     CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3165
3166     if (CL_err != CL_SUCCESS)
3167     {
3168       log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3169
3170       return -1;
3171     }
3172   }
3173
3174   if (num16m)
3175   {
3176     u32 tmp[4];
3177
3178     tmp[0] = value;
3179     tmp[1] = value;
3180     tmp[2] = value;
3181     tmp[3] = value;
3182
3183     CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
3184
3185     if (CL_err != CL_SUCCESS)
3186     {
3187       log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3188
3189       return -1;
3190     }
3191   }
3192
3193   return 0;
3194 }
3195
3196 static int run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
3197 {
3198   return run_kernel_memset (device_param, buf, 0, size);
3199 }
3200
3201 static int 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)
3202 {
3203   cl_int CL_err = CL_SUCCESS;
3204
3205   if (data.hash_mode == 2000)
3206   {
3207     process_stdout (device_param, pws_cnt);
3208
3209     return 0;
3210   }
3211
3212   if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3213   {
3214     if (attack_mode == ATTACK_MODE_BF)
3215     {
3216       if (opts_type & OPTS_TYPE_PT_BITSLICE)
3217       {
3218         const uint size_tm = 32 * sizeof (bs_word_t);
3219
3220         run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3221
3222         run_kernel_tm (device_param);
3223
3224         CL_err = 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);
3225
3226         if (CL_err != CL_SUCCESS)
3227         {
3228           log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3229
3230           return -1;
3231         }
3232       }
3233     }
3234
3235     if (highest_pw_len < 16)
3236     {
3237       run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3238     }
3239     else if (highest_pw_len < 32)
3240     {
3241       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3242     }
3243     else
3244     {
3245       run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3246     }
3247   }
3248   else
3249   {
3250     run_kernel_amp (device_param, pws_cnt);
3251
3252     run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3253
3254     if (opts_type & OPTS_TYPE_HOOK12)
3255     {
3256       run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3257
3258       CL_err = 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);
3259
3260       if (CL_err != CL_SUCCESS)
3261       {
3262         log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
3263
3264         return -1;
3265       }
3266
3267       // do something with data
3268
3269       CL_err = 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);
3270
3271       if (CL_err != CL_SUCCESS)
3272       {
3273         log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3274
3275         return -1;
3276       }
3277     }
3278
3279     uint iter = salt_buf->salt_iter;
3280
3281     uint loop_step = device_param->kernel_loops;
3282
3283     for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3284     {
3285       uint loop_left = iter - loop_pos;
3286
3287       loop_left = MIN (loop_left, loop_step);
3288
3289       device_param->kernel_params_buf32[28] = loop_pos;
3290       device_param->kernel_params_buf32[29] = loop_left;
3291
3292       run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3293
3294       if (data.devices_status == STATUS_CRACKED) break;
3295       if (data.devices_status == STATUS_ABORTED) break;
3296       if (data.devices_status == STATUS_QUIT)    break;
3297       if (data.devices_status == STATUS_BYPASS)  break;
3298
3299       /**
3300        * speed
3301        */
3302
3303       const float iter_part = (float) (loop_pos + loop_left) / iter;
3304
3305       const u64 perf_sum_all = pws_cnt * iter_part;
3306
3307       double speed_ms;
3308
3309       hc_timer_get (device_param->timer_speed, speed_ms);
3310
3311       const u32 speed_pos = device_param->speed_pos;
3312
3313       device_param->speed_cnt[speed_pos] = perf_sum_all;
3314
3315       device_param->speed_ms[speed_pos] = speed_ms;
3316
3317       if (data.benchmark == 1)
3318       {
3319         if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3320       }
3321     }
3322
3323     if (opts_type & OPTS_TYPE_HOOK23)
3324     {
3325       run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3326
3327       CL_err = 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);
3328
3329       if (CL_err != CL_SUCCESS)
3330       {
3331         log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
3332
3333         return -1;
3334       }
3335
3336       // do something with data
3337
3338       CL_err = 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);
3339
3340       if (CL_err != CL_SUCCESS)
3341       {
3342         log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3343
3344         return -1;
3345       }
3346     }
3347
3348     run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3349   }
3350
3351   return 0;
3352 }
3353
3354 static int run_rule_engine (const int rule_len, const char *rule_buf)
3355 {
3356   if (rule_len == 0)
3357   {
3358     return 0;
3359   }
3360   else if (rule_len == 1)
3361   {
3362     if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3363   }
3364
3365   return 1;
3366 }
3367
3368 static int run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3369 {
3370   cl_int CL_err = CL_SUCCESS;
3371
3372   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3373   {
3374     CL_err = 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);
3375
3376     if (CL_err != CL_SUCCESS)
3377     {
3378       log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3379
3380       return -1;
3381     }
3382   }
3383   else if (data.attack_kern == ATTACK_KERN_COMBI)
3384   {
3385     if (data.attack_mode == ATTACK_MODE_COMBI)
3386     {
3387       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3388       {
3389         if (data.opts_type & OPTS_TYPE_PT_ADD01)
3390         {
3391           for (u32 i = 0; i < pws_cnt; i++)
3392           {
3393             const u32 pw_len = device_param->pws_buf[i].pw_len;
3394
3395             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3396
3397             ptr[pw_len] = 0x01;
3398           }
3399         }
3400         else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3401         {
3402           for (u32 i = 0; i < pws_cnt; i++)
3403           {
3404             const u32 pw_len = device_param->pws_buf[i].pw_len;
3405
3406             u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3407
3408             ptr[pw_len] = 0x80;
3409           }
3410         }
3411       }
3412     }
3413     else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3414     {
3415       if (data.opts_type & OPTS_TYPE_PT_ADD01)
3416       {
3417         for (u32 i = 0; i < pws_cnt; i++)
3418         {
3419           const u32 pw_len = device_param->pws_buf[i].pw_len;
3420
3421           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3422
3423           ptr[pw_len] = 0x01;
3424         }
3425       }
3426       else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3427       {
3428         for (u32 i = 0; i < pws_cnt; i++)
3429         {
3430           const u32 pw_len = device_param->pws_buf[i].pw_len;
3431
3432           u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3433
3434           ptr[pw_len] = 0x80;
3435         }
3436       }
3437     }
3438
3439     CL_err = 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);
3440
3441     if (CL_err != CL_SUCCESS)
3442     {
3443       log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3444
3445       return -1;
3446     }
3447   }
3448   else if (data.attack_kern == ATTACK_KERN_BF)
3449   {
3450     const u64 off = device_param->words_off;
3451
3452     device_param->kernel_params_mp_l_buf64[3] = off;
3453
3454     run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3455   }
3456
3457   return 0;
3458 }
3459
3460 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3461 {
3462   const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3463
3464   device_param->kernel_params_buf32[28] = 0;
3465   device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3466   device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3467
3468   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3469   {
3470     run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3471   }
3472   else
3473   {
3474     run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3475   }
3476
3477   const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3478
3479   return exec_ms_prev;
3480 }
3481
3482 static int autotune (hc_device_param_t *device_param)
3483 {
3484   const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3485
3486   const u32 kernel_accel_min = device_param->kernel_accel_min;
3487   const u32 kernel_accel_max = device_param->kernel_accel_max;
3488
3489   const u32 kernel_loops_min = device_param->kernel_loops_min;
3490   const u32 kernel_loops_max = device_param->kernel_loops_max;
3491
3492   u32 kernel_accel = kernel_accel_min;
3493   u32 kernel_loops = kernel_loops_min;
3494
3495   // in this case the user specified a fixed -u and -n on the commandline
3496   // no way to tune anything
3497   // but we need to run a few caching rounds
3498
3499   if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3500   {
3501     if (data.hash_mode != 2000)
3502     {
3503       try_run (device_param, kernel_accel, kernel_loops);
3504       try_run (device_param, kernel_accel, kernel_loops);
3505       try_run (device_param, kernel_accel, kernel_loops);
3506       try_run (device_param, kernel_accel, kernel_loops);
3507     }
3508
3509     device_param->kernel_accel = kernel_accel;
3510     device_param->kernel_loops = kernel_loops;
3511
3512     const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3513
3514     device_param->kernel_power = kernel_power;
3515
3516     return 0;
3517   }
3518
3519   // from here it's clear we are allowed to autotune
3520   // so let's init some fake words
3521
3522   const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3523
3524   if (data.attack_kern == ATTACK_KERN_BF)
3525   {
3526     run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3527   }
3528   else
3529   {
3530     for (u32 i = 0; i < kernel_power_max; i++)
3531     {
3532       device_param->pws_buf[i].i[0]   = i;
3533       device_param->pws_buf[i].i[1]   = 0x01234567;
3534       device_param->pws_buf[i].pw_len = 7 + (i & 7);
3535     }
3536
3537     cl_int CL_err = 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);
3538
3539     if (CL_err != CL_SUCCESS)
3540     {
3541       log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3542
3543       return -1;
3544     }
3545   }
3546
3547   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3548   {
3549     if (data.kernel_rules_cnt > 1)
3550     {
3551       cl_int CL_err = 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);
3552
3553       if (CL_err != CL_SUCCESS)
3554       {
3555         log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3556
3557         return -1;
3558       }
3559     }
3560   }
3561   else
3562   {
3563     run_kernel_amp (device_param, kernel_power_max);
3564   }
3565
3566   #define VERIFIER_CNT 1
3567
3568   // first find out highest kernel-loops that stays below target_ms
3569
3570   if (kernel_loops_min < kernel_loops_max)
3571   {
3572     for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3573     {
3574       double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3575
3576       for (int i = 0; i < VERIFIER_CNT; i++)
3577       {
3578         double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3579
3580         exec_ms = MIN (exec_ms, exec_ms_v);
3581       }
3582
3583       if (exec_ms < target_ms) break;
3584     }
3585   }
3586
3587   // now the same for kernel-accel but with the new kernel-loops from previous loop set
3588
3589   #define STEPS_CNT 10
3590
3591   if (kernel_accel_min < kernel_accel_max)
3592   {
3593     for (int i = 0; i < STEPS_CNT; i++)
3594     {
3595       const u32 kernel_accel_try = 1 << i;
3596
3597       if (kernel_accel_try < kernel_accel_min) continue;
3598       if (kernel_accel_try > kernel_accel_max) break;
3599
3600       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3601
3602       for (int i = 0; i < VERIFIER_CNT; i++)
3603       {
3604         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3605
3606         exec_ms = MIN (exec_ms, exec_ms_v);
3607       }
3608
3609       if (exec_ms > target_ms) break;
3610
3611       kernel_accel = kernel_accel_try;
3612     }
3613   }
3614
3615   // at this point we want to know the actual runtime for the following reason:
3616   // we need a reference for the balancing loop following up, and this
3617   // the balancing loop can have an effect that the creates a new opportunity, for example:
3618   //   if the target is 95 ms and the current runtime is 48ms the above loop
3619   //   stopped the execution because the previous exec_ms was > 95ms
3620   //   due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3621   //   and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3622
3623   double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3624
3625   for (int i = 0; i < VERIFIER_CNT; i++)
3626   {
3627     double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3628
3629     exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3630   }
3631
3632   u32 diff = kernel_loops - kernel_accel;
3633
3634   if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3635   {
3636     u32 kernel_accel_orig = kernel_accel;
3637     u32 kernel_loops_orig = kernel_loops;
3638
3639     for (u32 f = 1; f < 1024; f++)
3640     {
3641       const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3642       const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3643
3644       if (kernel_accel_try > kernel_accel_max) break;
3645       if (kernel_loops_try < kernel_loops_min) break;
3646
3647       u32 diff_new = kernel_loops_try - kernel_accel_try;
3648
3649       if (diff_new > diff) break;
3650
3651       diff_new = diff;
3652
3653       double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3654
3655       for (int i = 0; i < VERIFIER_CNT; i++)
3656       {
3657         double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3658
3659         exec_ms = MIN (exec_ms, exec_ms_v);
3660       }
3661
3662       if (exec_ms < exec_ms_pre_final)
3663       {
3664         exec_ms_pre_final = exec_ms;
3665
3666         kernel_accel = kernel_accel_try;
3667         kernel_loops = kernel_loops_try;
3668       }
3669     }
3670   }
3671
3672   const double exec_left = target_ms / exec_ms_pre_final;
3673
3674   const double accel_left = kernel_accel_max / kernel_accel;
3675
3676   const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3677
3678   if (exec_accel_min >= 1.0)
3679   {
3680     // this is safe to not overflow kernel_accel_max because of accel_left
3681
3682     kernel_accel = (double) kernel_accel * exec_accel_min;
3683   }
3684
3685   // reset them fake words
3686
3687   /*
3688   memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3689
3690   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);
3691   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);
3692   */
3693
3694   run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3695
3696   if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3697   {
3698     run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3699   }
3700
3701   // reset timer
3702
3703   device_param->exec_pos = 0;
3704
3705   memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3706
3707   memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3708   memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3709   memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3710
3711   // store
3712
3713   device_param->kernel_accel = kernel_accel;
3714   device_param->kernel_loops = kernel_loops;
3715
3716   const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3717
3718   device_param->kernel_power = kernel_power;
3719
3720   #ifdef DEBUG
3721
3722   if (data.quiet == 0)
3723   {
3724     clear_prompt ();
3725
3726     log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3727               "- Device #%u: autotuned kernel-loops to %u\n",
3728               device_param->device_id + 1, kernel_accel,
3729               device_param->device_id + 1, kernel_loops);
3730
3731     fprintf (stdout, "%s", PROMPT);
3732
3733     fflush (stdout);
3734   }
3735
3736   #endif
3737
3738   return 0;
3739 }
3740
3741 static int run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3742 {
3743   char *line_buf = (char *) mymalloc (HCBUFSIZ);
3744
3745   // init speed timer
3746
3747   uint speed_pos = device_param->speed_pos;
3748
3749   #ifdef _POSIX
3750   if (device_param->timer_speed.tv_sec == 0)
3751   {
3752     hc_timer_set (&device_param->timer_speed);
3753   }
3754   #endif
3755
3756   #ifdef _WIN
3757   if (device_param->timer_speed.QuadPart == 0)
3758   {
3759     hc_timer_set (&device_param->timer_speed);
3760   }
3761   #endif
3762
3763   // find higest password length, this is for optimization stuff
3764
3765   uint highest_pw_len = 0;
3766
3767   if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3768   {
3769   }
3770   else if (data.attack_kern == ATTACK_KERN_COMBI)
3771   {
3772   }
3773   else if (data.attack_kern == ATTACK_KERN_BF)
3774   {
3775     highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3776                    + device_param->kernel_params_mp_l_buf32[5];
3777   }
3778
3779   // iteration type
3780
3781   uint innerloop_step = 0;
3782   uint innerloop_cnt  = 0;
3783
3784   if      (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)   innerloop_step = device_param->kernel_loops;
3785   else                                                      innerloop_step = 1;
3786
3787   if      (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt  = data.kernel_rules_cnt;
3788   else if (data.attack_kern == ATTACK_KERN_COMBI)    innerloop_cnt  = data.combs_cnt;
3789   else if (data.attack_kern == ATTACK_KERN_BF)       innerloop_cnt  = data.bfs_cnt;
3790
3791   // loop start: most outer loop = salt iteration, then innerloops (if multi)
3792
3793   for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3794   {
3795     while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3796
3797     if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3798
3799     if (data.devices_status == STATUS_CRACKED) break;
3800     if (data.devices_status == STATUS_ABORTED) break;
3801     if (data.devices_status == STATUS_QUIT)    break;
3802     if (data.devices_status == STATUS_BYPASS)  break;
3803
3804     salt_t *salt_buf = &data.salts_buf[salt_pos];
3805
3806     device_param->kernel_params_buf32[27] = salt_pos;
3807     device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3808     device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3809
3810     FILE *combs_fp = device_param->combs_fp;
3811
3812     if (data.attack_mode == ATTACK_MODE_COMBI)
3813     {
3814       rewind (combs_fp);
3815     }
3816
3817     // innerloops
3818
3819     for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3820     {
3821       while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3822
3823       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3824
3825       if (data.devices_status == STATUS_CRACKED) break;
3826       if (data.devices_status == STATUS_ABORTED) break;
3827       if (data.devices_status == STATUS_QUIT)    break;
3828       if (data.devices_status == STATUS_BYPASS)  break;
3829
3830       uint fast_iteration = 0;
3831
3832       uint innerloop_left = innerloop_cnt - innerloop_pos;
3833
3834       if (innerloop_left > innerloop_step)
3835       {
3836         innerloop_left = innerloop_step;
3837
3838         fast_iteration = 1;
3839       }
3840
3841       device_param->innerloop_pos  = innerloop_pos;
3842       device_param->innerloop_left = innerloop_left;
3843
3844       device_param->kernel_params_buf32[30] = innerloop_left;
3845
3846       // i think we can get rid of this
3847       if (innerloop_left == 0)
3848       {
3849         puts ("bug, how should this happen????\n");
3850
3851         continue;
3852       }
3853
3854       if (data.salts_shown[salt_pos] == 1)
3855       {
3856         data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3857
3858         continue;
3859       }
3860
3861       // initialize amplifiers
3862
3863       if (data.attack_mode == ATTACK_MODE_COMBI)
3864       {
3865         uint i = 0;
3866
3867         while (i < innerloop_left)
3868         {
3869           if (feof (combs_fp)) break;
3870
3871           int line_len = fgetl (combs_fp, line_buf);
3872
3873           if (line_len >= PW_MAX1) continue;
3874
3875           line_len = convert_from_hex (line_buf, line_len);
3876
3877           char *line_buf_new = line_buf;
3878
3879           if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3880           {
3881             char rule_buf_out[BLOCK_SIZE] = { 0 };
3882
3883             int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3884
3885             if (rule_len_out < 0)
3886             {
3887               data.words_progress_rejected[salt_pos] += pws_cnt;
3888
3889               continue;
3890             }
3891
3892             line_len = rule_len_out;
3893
3894             line_buf_new = rule_buf_out;
3895           }
3896
3897           line_len = MIN (line_len, PW_DICTMAX);
3898
3899           u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3900
3901           memcpy (ptr, line_buf_new, line_len);
3902
3903           memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3904
3905           if (data.opts_type & OPTS_TYPE_PT_UPPER)
3906           {
3907             uppercase (ptr, line_len);
3908           }
3909
3910           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3911           {
3912             if (data.opts_type & OPTS_TYPE_PT_ADD80)
3913             {
3914               ptr[line_len] = 0x80;
3915             }
3916
3917             if (data.opts_type & OPTS_TYPE_PT_ADD01)
3918             {
3919               ptr[line_len] = 0x01;
3920             }
3921           }
3922
3923           device_param->combs_buf[i].pw_len = line_len;
3924
3925           i++;
3926         }
3927
3928         for (uint j = i; j < innerloop_left; j++)
3929         {
3930           device_param->combs_buf[j].i[0] = 0;
3931           device_param->combs_buf[j].i[1] = 0;
3932           device_param->combs_buf[j].i[2] = 0;
3933           device_param->combs_buf[j].i[3] = 0;
3934           device_param->combs_buf[j].i[4] = 0;
3935           device_param->combs_buf[j].i[5] = 0;
3936           device_param->combs_buf[j].i[6] = 0;
3937           device_param->combs_buf[j].i[7] = 0;
3938
3939           device_param->combs_buf[j].pw_len = 0;
3940         }
3941
3942         innerloop_left = i;
3943       }
3944       else if (data.attack_mode == ATTACK_MODE_BF)
3945       {
3946         u64 off = innerloop_pos;
3947
3948         device_param->kernel_params_mp_r_buf64[3] = off;
3949
3950         run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3951       }
3952       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3953       {
3954         u64 off = innerloop_pos;
3955
3956         device_param->kernel_params_mp_buf64[3] = off;
3957
3958         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3959       }
3960       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3961       {
3962         u64 off = innerloop_pos;
3963
3964         device_param->kernel_params_mp_buf64[3] = off;
3965
3966         run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3967       }
3968
3969       // copy amplifiers
3970
3971       if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3972       {
3973         cl_int CL_err = 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);
3974
3975         if (CL_err != CL_SUCCESS)
3976         {
3977           log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3978
3979           return -1;
3980         }
3981       }
3982       else if (data.attack_mode == ATTACK_MODE_COMBI)
3983       {
3984         cl_int CL_err = 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);
3985
3986         if (CL_err != CL_SUCCESS)
3987         {
3988           log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3989
3990           return -1;
3991         }
3992       }
3993       else if (data.attack_mode == ATTACK_MODE_BF)
3994       {
3995         cl_int CL_err = 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);
3996
3997         if (CL_err != CL_SUCCESS)
3998         {
3999           log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4000
4001           return -1;
4002         }
4003       }
4004       else if (data.attack_mode == ATTACK_MODE_HYBRID1)
4005       {
4006         cl_int CL_err = 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);
4007
4008         if (CL_err != CL_SUCCESS)
4009         {
4010           log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4011
4012           return -1;
4013         }
4014       }
4015       else if (data.attack_mode == ATTACK_MODE_HYBRID2)
4016       {
4017         cl_int CL_err = 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);
4018
4019         if (CL_err != CL_SUCCESS)
4020         {
4021           log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4022
4023           return -1;
4024         }
4025       }
4026
4027       if (data.benchmark == 1)
4028       {
4029         hc_timer_set (&device_param->timer_speed);
4030       }
4031
4032       int rc = choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
4033
4034       if (rc == -1) return -1;
4035
4036       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4037
4038       if (data.devices_status == STATUS_CRACKED) break;
4039       if (data.devices_status == STATUS_ABORTED) break;
4040       if (data.devices_status == STATUS_QUIT)    break;
4041       if (data.devices_status == STATUS_BYPASS)  break;
4042
4043       /**
4044        * result
4045        */
4046
4047       if (data.benchmark == 0)
4048       {
4049         check_cracked (device_param, salt_pos);
4050       }
4051
4052       /**
4053        * progress
4054        */
4055
4056       u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
4057
4058       hc_thread_mutex_lock (mux_counter);
4059
4060       data.words_progress_done[salt_pos] += perf_sum_all;
4061
4062       hc_thread_mutex_unlock (mux_counter);
4063
4064       /**
4065        * speed
4066        */
4067
4068       double speed_ms;
4069
4070       hc_timer_get (device_param->timer_speed, speed_ms);
4071
4072       hc_timer_set (&device_param->timer_speed);
4073
4074       // current speed
4075
4076       //hc_thread_mutex_lock (mux_display);
4077
4078       device_param->speed_cnt[speed_pos] = perf_sum_all;
4079
4080       device_param->speed_ms[speed_pos] = speed_ms;
4081
4082       //hc_thread_mutex_unlock (mux_display);
4083
4084       speed_pos++;
4085
4086       if (speed_pos == SPEED_CACHE)
4087       {
4088         speed_pos = 0;
4089       }
4090
4091       /**
4092        * benchmark
4093        */
4094
4095       if (data.benchmark == 1) break;
4096     }
4097   }
4098
4099   device_param->speed_pos = speed_pos;
4100
4101   myfree (line_buf);
4102
4103   return 0;
4104 }
4105
4106 static void load_segment (wl_data_t *wl_data, FILE *fd)
4107 {
4108   // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
4109
4110   wl_data->pos = 0;
4111
4112   wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
4113
4114   wl_data->buf[wl_data->cnt] = 0;
4115
4116   if (wl_data->cnt == 0) return;
4117
4118   if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
4119
4120   while (!feof (fd))
4121   {
4122     if (wl_data->cnt == wl_data->avail)
4123     {
4124       wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
4125
4126       wl_data->avail += wl_data->incr;
4127     }
4128
4129     const int c = fgetc (fd);
4130
4131     if (c == EOF) break;
4132
4133     wl_data->buf[wl_data->cnt] = (char) c;
4134
4135     wl_data->cnt++;
4136
4137     if (c == '\n') break;
4138   }
4139
4140   // ensure stream ends with a newline
4141
4142   if (wl_data->buf[wl_data->cnt - 1] != '\n')
4143   {
4144     wl_data->cnt++;
4145
4146     wl_data->buf[wl_data->cnt - 1] = '\n';
4147   }
4148
4149   return;
4150 }
4151
4152 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
4153 {
4154   char *ptr = buf;
4155
4156   for (u32 i = 0; i < sz; i++, ptr++)
4157   {
4158     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
4159
4160     if (i == 7)
4161     {
4162       *off = i;
4163       *len = i;
4164
4165       return;
4166     }
4167
4168     if (*ptr != '\n') continue;
4169
4170     *off = i + 1;
4171
4172     if ((i > 0) && (buf[i - 1] == '\r')) i--;
4173
4174     *len = i;
4175
4176     return;
4177   }
4178
4179   *off = sz;
4180   *len = sz;
4181 }
4182
4183 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
4184 {
4185   char *ptr = buf;
4186
4187   for (u32 i = 0; i < sz; i++, ptr++)
4188   {
4189     if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
4190
4191     if (*ptr != '\n') continue;
4192
4193     *off = i + 1;
4194
4195     if ((i > 0) && (buf[i - 1] == '\r')) i--;
4196
4197     *len = i;
4198
4199     return;
4200   }
4201
4202   *off = sz;
4203   *len = sz;
4204 }
4205
4206 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
4207 {
4208   char *ptr = buf;
4209
4210   for (u32 i = 0; i < sz; i++, ptr++)
4211   {
4212     if (*ptr != '\n') continue;
4213
4214     *off = i + 1;
4215
4216     if ((i > 0) && (buf[i - 1] == '\r')) i--;
4217
4218     *len = i;
4219
4220     return;
4221   }
4222
4223   *off = sz;
4224   *len = sz;
4225 }
4226
4227 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
4228 {
4229   while (wl_data->pos < wl_data->cnt)
4230   {
4231     uint off;
4232     uint len;
4233
4234     char *ptr = wl_data->buf + wl_data->pos;
4235
4236     get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
4237
4238     wl_data->pos += off;
4239
4240     if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4241     {
4242       char rule_buf_out[BLOCK_SIZE] = { 0 };
4243
4244       int rule_len_out = -1;
4245
4246       if (len < BLOCK_SIZE)
4247       {
4248         rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
4249       }
4250
4251       if (rule_len_out < 0)
4252       {
4253         continue;
4254       }
4255
4256       if (rule_len_out > PW_MAX)
4257       {
4258         continue;
4259       }
4260     }
4261     else
4262     {
4263       if (len > PW_MAX)
4264       {
4265         continue;
4266       }
4267     }
4268
4269     *out_buf = ptr;
4270     *out_len = len;
4271
4272     return;
4273   }
4274
4275   if (feof (fd))
4276   {
4277     fprintf (stderr, "BUG feof()!!\n");
4278
4279     return;
4280   }
4281
4282   load_segment (wl_data, fd);
4283
4284   get_next_word (wl_data, fd, out_buf, out_len);
4285 }
4286
4287 #ifdef _POSIX
4288 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
4289 #endif
4290
4291 #ifdef _WIN
4292 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
4293 #endif
4294 {
4295   hc_signal (NULL);
4296
4297   dictstat_t d;
4298
4299   d.cnt = 0;
4300
4301   #ifdef _POSIX
4302   fstat (fileno (fd), &d.stat);
4303   #endif
4304
4305   #ifdef _WIN
4306   _fstat64 (fileno (fd), &d.stat);
4307   #endif
4308
4309   d.stat.st_mode    = 0;
4310   d.stat.st_nlink   = 0;
4311   d.stat.st_uid     = 0;
4312   d.stat.st_gid     = 0;
4313   d.stat.st_rdev    = 0;
4314   d.stat.st_atime   = 0;
4315
4316   #ifdef _POSIX
4317   d.stat.st_blksize = 0;
4318   d.stat.st_blocks  = 0;
4319   #endif
4320
4321   if (d.stat.st_size == 0) return 0;
4322
4323   dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4324
4325   if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4326   {
4327     if (d_cache)
4328     {
4329       u64 cnt = d_cache->cnt;
4330
4331       u64 keyspace = cnt;
4332
4333       if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4334       {
4335         keyspace *= data.kernel_rules_cnt;
4336       }
4337       else if (data.attack_kern == ATTACK_KERN_COMBI)
4338       {
4339         keyspace *= data.combs_cnt;
4340       }
4341
4342       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);
4343       if (data.quiet == 0) log_info ("");
4344
4345       hc_signal (sigHandler_default);
4346
4347       return (keyspace);
4348     }
4349   }
4350
4351   time_t now  = 0;
4352   time_t prev = 0;
4353
4354   u64 comp = 0;
4355   u64 cnt  = 0;
4356   u64 cnt2 = 0;
4357
4358   while (!feof (fd))
4359   {
4360     load_segment (wl_data, fd);
4361
4362     comp += wl_data->cnt;
4363
4364     u32 i = 0;
4365
4366     while (i < wl_data->cnt)
4367     {
4368       u32 len;
4369       u32 off;
4370
4371       get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4372
4373       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4374       {
4375         char rule_buf_out[BLOCK_SIZE] = { 0 };
4376
4377         int rule_len_out = -1;
4378
4379         if (len < BLOCK_SIZE)
4380         {
4381           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4382         }
4383
4384         if (rule_len_out < 0)
4385         {
4386           len = PW_MAX1;
4387         }
4388         else
4389         {
4390           len = rule_len_out;
4391         }
4392       }
4393
4394       if (len < PW_MAX1)
4395       {
4396         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4397         {
4398           cnt += data.kernel_rules_cnt;
4399         }
4400         else if (data.attack_kern == ATTACK_KERN_COMBI)
4401         {
4402           cnt += data.combs_cnt;
4403         }
4404
4405         d.cnt++;
4406       }
4407
4408       i += off;
4409
4410       cnt2++;
4411     }
4412
4413     time (&now);
4414
4415     if ((now - prev) == 0) continue;
4416
4417     float percent = (float) comp / (float) d.stat.st_size;
4418
4419     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);
4420
4421     time (&prev);
4422   }
4423
4424   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);
4425   if (data.quiet == 0) log_info ("");
4426
4427   lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4428
4429   hc_signal (sigHandler_default);
4430
4431   return (cnt);
4432 }
4433
4434 static void *thread_monitor (void *p)
4435 {
4436   uint runtime_check = 0;
4437   uint remove_check  = 0;
4438   uint status_check  = 0;
4439   uint restore_check = 0;
4440
4441   uint restore_left = data.restore_timer;
4442   uint remove_left  = data.remove_timer;
4443   uint status_left  = data.status_timer;
4444
4445   #ifdef HAVE_HWMON
4446   uint hwmon_check = 0;
4447
4448   int slowdown_warnings = 0;
4449
4450   // these variables are mainly used for fan control
4451
4452   int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4453
4454   // temperature controller "loopback" values
4455
4456   int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4457   int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4458
4459   int temp_threshold = 1; // degrees celcius
4460
4461   int fan_speed_min =  15; // in percentage
4462   int fan_speed_max = 100;
4463
4464   time_t last_temp_check_time;
4465   #endif // HAVE_HWMON
4466
4467   uint sleep_time = 1;
4468
4469   if (data.runtime)
4470   {
4471     runtime_check = 1;
4472   }
4473
4474   if (data.restore_timer)
4475   {
4476     restore_check = 1;
4477   }
4478
4479   if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4480   {
4481     remove_check = 1;
4482   }
4483
4484   if (data.status == 1)
4485   {
4486     status_check = 1;
4487   }
4488
4489   #ifdef HAVE_HWMON
4490   if (data.gpu_temp_disable == 0)
4491   {
4492     time (&last_temp_check_time);
4493
4494     hwmon_check = 1;
4495   }
4496   #endif
4497
4498   if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4499   {
4500     #ifdef HAVE_HWMON
4501     if (hwmon_check == 0)
4502     #endif
4503     return (p);
4504   }
4505
4506   while (data.shutdown_inner == 0)
4507   {
4508     hc_sleep (sleep_time);
4509
4510     if (data.devices_status != STATUS_RUNNING) continue;
4511
4512     #ifdef HAVE_HWMON
4513
4514     if (hwmon_check == 1)
4515     {
4516       hc_thread_mutex_lock (mux_adl);
4517
4518       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4519       {
4520         hc_device_param_t *device_param = &data.devices_param[device_id];
4521
4522         if (device_param->skipped) continue;
4523
4524         if (device_param->device_vendor_id == VENDOR_ID_NV)
4525         {
4526           if (data.hm_nvapi)
4527           {
4528             NV_GPU_PERF_POLICIES_INFO_PARAMS_V1   perfPolicies_info;
4529             NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status;
4530
4531             memset (&perfPolicies_info,   0, sizeof (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1));
4532             memset (&perfPolicies_status, 0, sizeof (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1));
4533
4534             perfPolicies_info.version   = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4535             perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4536
4537             hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4538
4539             perfPolicies_status.info_value = perfPolicies_info.info_value;
4540
4541             hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4542
4543             if (perfPolicies_status.throttle & 2)
4544             {
4545               if (slowdown_warnings < 3)
4546               {
4547                 if (data.quiet == 0) clear_prompt ();
4548
4549                 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4550
4551                 if (slowdown_warnings == 2)
4552                 {
4553                   log_info ("");
4554                 }
4555
4556                 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4557                 if (data.quiet == 0) fflush (stdout);
4558
4559                 slowdown_warnings++;
4560               }
4561             }
4562             else
4563             {
4564               slowdown_warnings = 0;
4565             }
4566           }
4567         }
4568       }
4569
4570       hc_thread_mutex_unlock (mux_adl);
4571     }
4572
4573     if (hwmon_check == 1)
4574     {
4575       hc_thread_mutex_lock (mux_adl);
4576
4577       time_t temp_check_time;
4578
4579       time (&temp_check_time);
4580
4581       uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4582
4583       if (Ta == 0) Ta = 1;
4584
4585       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4586       {
4587         hc_device_param_t *device_param = &data.devices_param[device_id];
4588
4589         if (device_param->skipped) continue;
4590
4591         if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4592
4593         const int temperature = hm_get_temperature_with_device_id (device_id);
4594
4595         if (temperature > (int) data.gpu_temp_abort)
4596         {
4597           log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4598
4599           if (data.devices_status != STATUS_QUIT) myabort ();
4600
4601           break;
4602         }
4603
4604         const int gpu_temp_retain = data.gpu_temp_retain;
4605
4606         if (gpu_temp_retain)
4607         {
4608           if (data.hm_device[device_id].fan_set_supported == 1)
4609           {
4610             int temp_cur = temperature;
4611
4612             int temp_diff_new = gpu_temp_retain - temp_cur;
4613
4614             temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4615
4616             // calculate Ta value (time difference in seconds between the last check and this check)
4617
4618             last_temp_check_time = temp_check_time;
4619
4620             float Kp = 1.8;
4621             float Ki = 0.005;
4622             float Kd = 6;
4623
4624             // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4625
4626             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);
4627
4628             if (abs (fan_diff_required) >= temp_threshold)
4629             {
4630               const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4631
4632               int fan_speed_level = fan_speed_cur;
4633
4634               if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4635
4636               int fan_speed_new = fan_speed_level - fan_diff_required;
4637
4638               if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4639               if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4640
4641               if (fan_speed_new != fan_speed_cur)
4642               {
4643                 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4644                 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4645
4646                 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4647                 {
4648                   if (device_param->device_vendor_id == VENDOR_ID_AMD)
4649                   {
4650                     hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4651                   }
4652                   else if (device_param->device_vendor_id == VENDOR_ID_NV)
4653                   {
4654                     #ifdef WIN
4655                     hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4656                     #endif
4657
4658                     #ifdef __linux__
4659                     hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4660                     #endif
4661                   }
4662
4663                   fan_speed_chgd[device_id] = 1;
4664                 }
4665
4666                 temp_diff_old[device_id] = temp_diff_new;
4667               }
4668             }
4669           }
4670         }
4671       }
4672
4673       hc_thread_mutex_unlock (mux_adl);
4674     }
4675     #endif // HAVE_HWMON
4676
4677     if (restore_check == 1)
4678     {
4679       restore_left--;
4680
4681       if (restore_left == 0)
4682       {
4683         if (data.restore_disable == 0) cycle_restore ();
4684
4685         restore_left = data.restore_timer;
4686       }
4687     }
4688
4689     if ((runtime_check == 1) && (data.runtime_start > 0))
4690     {
4691       time_t runtime_cur;
4692
4693       time (&runtime_cur);
4694
4695       int runtime_left = data.proc_start + data.runtime - runtime_cur;
4696
4697       if (runtime_left <= 0)
4698       {
4699         if (data.benchmark == 0)
4700         {
4701           if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4702         }
4703
4704         if (data.devices_status != STATUS_QUIT) myabort ();
4705       }
4706     }
4707
4708     if (remove_check == 1)
4709     {
4710       remove_left--;
4711
4712       if (remove_left == 0)
4713       {
4714         if (data.digests_saved != data.digests_done)
4715         {
4716           data.digests_saved = data.digests_done;
4717
4718           save_hash ();
4719         }
4720
4721         remove_left = data.remove_timer;
4722       }
4723     }
4724
4725     if (status_check == 1)
4726     {
4727       status_left--;
4728
4729       if (status_left == 0)
4730       {
4731         hc_thread_mutex_lock (mux_display);
4732
4733         if (data.quiet == 0) clear_prompt ();
4734
4735         if (data.quiet == 0) log_info ("");
4736
4737         status_display ();
4738
4739         if (data.quiet == 0) log_info ("");
4740
4741         hc_thread_mutex_unlock (mux_display);
4742
4743         status_left = data.status_timer;
4744       }
4745     }
4746   }
4747
4748   #ifdef HAVE_HWMON
4749   myfree (fan_speed_chgd);
4750
4751   myfree (temp_diff_old);
4752   myfree (temp_diff_sum);
4753   #endif
4754
4755   p = NULL;
4756
4757   return (p);
4758 }
4759
4760 static void *thread_outfile_remove (void *p)
4761 {
4762   // some hash-dependent constants
4763   char *outfile_dir = data.outfile_check_directory;
4764   uint dgst_size    = data.dgst_size;
4765   uint isSalted     = data.isSalted;
4766   uint esalt_size   = data.esalt_size;
4767   uint hash_mode    = data.hash_mode;
4768
4769   uint outfile_check_timer = data.outfile_check_timer;
4770
4771   char separator = data.separator;
4772
4773   // some hash-dependent functions
4774   int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4775   int (*parse_func) (char *, uint, hash_t *)         = data.parse_func;
4776
4777   // buffers
4778   hash_t hash_buf = { 0, 0, 0, 0, 0 };
4779
4780   hash_buf.digest = mymalloc (dgst_size);
4781
4782   if (isSalted)   hash_buf.salt =  (salt_t *) mymalloc (sizeof (salt_t));
4783
4784   if (esalt_size) hash_buf.esalt = (void   *) mymalloc (esalt_size);
4785
4786   uint digest_buf[64] = { 0 };
4787
4788   outfile_data_t *out_info = NULL;
4789
4790   char **out_files = NULL;
4791
4792   time_t folder_mtime = 0;
4793
4794   int  out_cnt = 0;
4795
4796   uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4797
4798   while (data.shutdown_inner == 0)
4799   {
4800     hc_sleep (1);
4801
4802     if (data.devices_status != STATUS_RUNNING) continue;
4803
4804     check_left--;
4805
4806     if (check_left == 0)
4807     {
4808       struct stat outfile_check_stat;
4809
4810       if (stat (outfile_dir, &outfile_check_stat) == 0)
4811       {
4812         uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4813
4814         if (is_dir == 1)
4815         {
4816           if (outfile_check_stat.st_mtime > folder_mtime)
4817           {
4818             char **out_files_new = scan_directory (outfile_dir);
4819
4820             int out_cnt_new = count_dictionaries (out_files_new);
4821
4822             outfile_data_t *out_info_new = NULL;
4823
4824             if (out_cnt_new > 0)
4825             {
4826               out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4827
4828               for (int i = 0; i < out_cnt_new; i++)
4829               {
4830                 out_info_new[i].file_name = out_files_new[i];
4831
4832                 // check if there are files that we have seen/checked before (and not changed)
4833
4834                 for (int j = 0; j < out_cnt; j++)
4835                 {
4836                   if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4837                   {
4838                     struct stat outfile_stat;
4839
4840                     if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4841                     {
4842                       if (outfile_stat.st_ctime == out_info[j].ctime)
4843                       {
4844                         out_info_new[i].ctime = out_info[j].ctime;
4845                         out_info_new[i].seek  = out_info[j].seek;
4846                       }
4847                     }
4848                   }
4849                 }
4850               }
4851             }
4852
4853             local_free (out_info);
4854             local_free (out_files);
4855
4856             out_files = out_files_new;
4857             out_cnt   = out_cnt_new;
4858             out_info  = out_info_new;
4859
4860             folder_mtime = outfile_check_stat.st_mtime;
4861           }
4862
4863           for (int j = 0; j < out_cnt; j++)
4864           {
4865             FILE *fp = fopen (out_info[j].file_name, "rb");
4866
4867             if (fp != NULL)
4868             {
4869               //hc_thread_mutex_lock (mux_display);
4870
4871               #ifdef _POSIX
4872               struct stat outfile_stat;
4873
4874               fstat (fileno (fp), &outfile_stat);
4875               #endif
4876
4877               #ifdef _WIN
4878               struct stat64 outfile_stat;
4879
4880               _fstat64 (fileno (fp), &outfile_stat);
4881               #endif
4882
4883               if (outfile_stat.st_ctime > out_info[j].ctime)
4884               {
4885                 out_info[j].ctime = outfile_stat.st_ctime;
4886                 out_info[j].seek  = 0;
4887               }
4888
4889               fseek (fp, out_info[j].seek, SEEK_SET);
4890
4891               char *line_buf = (char *) mymalloc (HCBUFSIZ);
4892
4893               while (!feof (fp))
4894               {
4895                 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4896
4897                 if (ptr == NULL) break;
4898
4899                 int line_len = strlen (line_buf);
4900
4901                 if (line_len <= 0) continue;
4902
4903                 int iter = MAX_CUT_TRIES;
4904
4905                 for (uint i = line_len - 1; i && iter; i--, line_len--)
4906                 {
4907                   if (line_buf[i] != separator) continue;
4908
4909                   int parser_status = PARSER_OK;
4910
4911                   if ((hash_mode != 2500) && (hash_mode != 6800))
4912                   {
4913                     parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4914                   }
4915
4916                   uint found = 0;
4917
4918                   if (parser_status == PARSER_OK)
4919                   {
4920                     for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4921                     {
4922                       if (data.salts_shown[salt_pos] == 1) continue;
4923
4924                       salt_t *salt_buf = &data.salts_buf[salt_pos];
4925
4926                       for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4927                       {
4928                         uint idx = salt_buf->digests_offset + digest_pos;
4929
4930                         if (data.digests_shown[idx] == 1) continue;
4931
4932                         uint cracked = 0;
4933
4934                         if (hash_mode == 6800)
4935                         {
4936                           if (i == salt_buf->salt_len)
4937                           {
4938                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4939                           }
4940                         }
4941                         else if (hash_mode == 2500)
4942                         {
4943                           // BSSID : MAC1 : MAC2 (:plain)
4944                           if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4945                           {
4946                             cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4947
4948                             if (!cracked) continue;
4949
4950                             // now compare MAC1 and MAC2 too, since we have this additional info
4951                             char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4952                             char *mac2_pos = mac1_pos + 12 + 1;
4953
4954                             wpa_t *wpas = (wpa_t *) data.esalts_buf;
4955                             wpa_t *wpa  = &wpas[salt_pos];
4956
4957                             // compare hex string(s) vs binary MAC address(es)
4958
4959                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4960                             {
4961                               if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4962                               {
4963                                 cracked = 0;
4964
4965                                 break;
4966                               }
4967                             }
4968
4969                             // early skip ;)
4970                             if (!cracked) continue;
4971
4972                             for (uint i = 0, j = 0; i < 6; i++, j += 2)
4973                             {
4974                               if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4975                               {
4976                                 cracked = 0;
4977
4978                                 break;
4979                               }
4980                             }
4981                           }
4982                         }
4983                         else
4984                         {
4985                           char *digests_buf_ptr = (char *) data.digests_buf;
4986
4987                           memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4988
4989                           cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4990                         }
4991
4992                         if (cracked == 1)
4993                         {
4994                           found = 1;
4995
4996                           data.digests_shown[idx] = 1;
4997
4998                           data.digests_done++;
4999
5000                           salt_buf->digests_done++;
5001
5002                           if (salt_buf->digests_done == salt_buf->digests_cnt)
5003                           {
5004                             data.salts_shown[salt_pos] = 1;
5005
5006                             data.salts_done++;
5007
5008                             if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
5009                           }
5010                         }
5011                       }
5012
5013                       if (data.devices_status == STATUS_CRACKED) break;
5014                     }
5015                   }
5016
5017                   if (found) break;
5018
5019                   if (data.devices_status == STATUS_CRACKED) break;
5020
5021                   iter--;
5022                 }
5023
5024                 if (data.devices_status == STATUS_CRACKED) break;
5025               }
5026
5027               myfree (line_buf);
5028
5029               out_info[j].seek = ftell (fp);
5030
5031               //hc_thread_mutex_unlock (mux_display);
5032
5033               fclose (fp);
5034             }
5035           }
5036         }
5037       }
5038
5039       check_left = outfile_check_timer;
5040     }
5041   }
5042
5043   if (esalt_size) local_free (hash_buf.esalt);
5044
5045   if (isSalted)   local_free (hash_buf.salt);
5046
5047   local_free (hash_buf.digest);
5048
5049   local_free (out_info);
5050
5051   local_free (out_files);
5052
5053   p = NULL;
5054
5055   return (p);
5056 }
5057
5058 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
5059 {
5060   //if (device_param->pws_cnt < device_param->kernel_power)
5061   //{
5062     pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
5063
5064     u8 *ptr = (u8 *) pw->i;
5065
5066     memcpy (ptr, pw_buf, pw_len);
5067
5068     memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
5069
5070     pw->pw_len = pw_len;
5071
5072     device_param->pws_cnt++;
5073   //}
5074   //else
5075   //{
5076   //  fprintf (stderr, "BUG pw_add()!!\n");
5077   //
5078   //  return;
5079   //}
5080 }
5081
5082 static void set_kernel_power_final (const u64 kernel_power_final)
5083 {
5084   if (data.quiet == 0)
5085   {
5086     clear_prompt ();
5087
5088     //log_info ("");
5089
5090     log_info ("INFO: approaching final keyspace, workload adjusted");
5091     log_info ("");
5092
5093     fprintf (stdout, "%s", PROMPT);
5094
5095     fflush (stdout);
5096   }
5097
5098   data.kernel_power_final = kernel_power_final;
5099 }
5100
5101 static u32 get_power (hc_device_param_t *device_param)
5102 {
5103   const u64 kernel_power_final = data.kernel_power_final;
5104
5105   if (kernel_power_final)
5106   {
5107     const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
5108
5109     const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
5110
5111     // work should be at least the hardware power available without any accelerator
5112
5113     const u64 work = MAX (words_left_device, device_param->hardware_power);
5114
5115     return work;
5116   }
5117
5118   return device_param->kernel_power;
5119 }
5120
5121 static uint get_work (hc_device_param_t *device_param, const u64 max)
5122 {
5123   hc_thread_mutex_lock (mux_dispatcher);
5124
5125   const u64 words_cur  = data.words_cur;
5126   const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
5127
5128   device_param->words_off = words_cur;
5129
5130   const u64 kernel_power_all = data.kernel_power_all;
5131
5132   const u64 words_left = words_base - words_cur;
5133
5134   if (words_left < kernel_power_all)
5135   {
5136     if (data.kernel_power_final == 0)
5137     {
5138       set_kernel_power_final (words_left);
5139     }
5140   }
5141
5142   const u32 kernel_power = get_power (device_param);
5143
5144   uint work = MIN (words_left, kernel_power);
5145
5146   work = MIN (work, max);
5147
5148   data.words_cur += work;
5149
5150   hc_thread_mutex_unlock (mux_dispatcher);
5151
5152   return work;
5153 }
5154
5155 static void *thread_autotune (void *p)
5156 {
5157   hc_device_param_t *device_param = (hc_device_param_t *) p;
5158
5159   if (device_param->skipped) return NULL;
5160
5161   autotune (device_param);
5162
5163   return NULL;
5164 }
5165
5166 static void *thread_calc_stdin (void *p)
5167 {
5168   hc_device_param_t *device_param = (hc_device_param_t *) p;
5169
5170   if (device_param->skipped) return NULL;
5171
5172   char *buf = (char *) mymalloc (HCBUFSIZ);
5173
5174   const uint attack_kern = data.attack_kern;
5175
5176   while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5177   {
5178     hc_thread_mutex_lock (mux_dispatcher);
5179
5180     if (feof (stdin) != 0)
5181     {
5182       hc_thread_mutex_unlock (mux_dispatcher);
5183
5184       break;
5185     }
5186
5187     uint words_cur = 0;
5188
5189     while (words_cur < device_param->kernel_power)
5190     {
5191       char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
5192
5193       if (line_buf == NULL) break;
5194
5195       uint line_len = in_superchop (line_buf);
5196
5197       line_len = convert_from_hex (line_buf, line_len);
5198
5199       // post-process rule engine
5200
5201       if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5202       {
5203         char rule_buf_out[BLOCK_SIZE] = { 0 };
5204
5205         int rule_len_out = -1;
5206
5207         if (line_len < BLOCK_SIZE)
5208         {
5209           rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5210         }
5211
5212         if (rule_len_out < 0) continue;
5213
5214         line_buf = rule_buf_out;
5215         line_len = rule_len_out;
5216       }
5217
5218       if (line_len > PW_MAX)
5219       {
5220         continue;
5221       }
5222
5223       // hmm that's always the case, or?
5224
5225       if (attack_kern == ATTACK_KERN_STRAIGHT)
5226       {
5227         if ((line_len < data.pw_min) || (line_len > data.pw_max))
5228         {
5229           hc_thread_mutex_lock (mux_counter);
5230
5231           for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5232           {
5233             data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5234           }
5235
5236           hc_thread_mutex_unlock (mux_counter);
5237
5238           continue;
5239         }
5240       }
5241
5242       pw_add (device_param, (u8 *) line_buf, line_len);
5243
5244       words_cur++;
5245
5246       if (data.devices_status == STATUS_CRACKED) break;
5247       if (data.devices_status == STATUS_ABORTED) break;
5248       if (data.devices_status == STATUS_QUIT)    break;
5249       if (data.devices_status == STATUS_BYPASS)  break;
5250     }
5251
5252     hc_thread_mutex_unlock (mux_dispatcher);
5253
5254     if (data.devices_status == STATUS_CRACKED) break;
5255     if (data.devices_status == STATUS_ABORTED) break;
5256     if (data.devices_status == STATUS_QUIT)    break;
5257     if (data.devices_status == STATUS_BYPASS)  break;
5258
5259     // flush
5260
5261     const uint pws_cnt = device_param->pws_cnt;
5262
5263     if (pws_cnt)
5264     {
5265       run_copy (device_param, pws_cnt);
5266
5267       run_cracker (device_param, pws_cnt);
5268
5269       device_param->pws_cnt = 0;
5270
5271       /*
5272       still required?
5273       if (attack_kern == ATTACK_KERN_STRAIGHT)
5274       {
5275         run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5276       }
5277       else if (attack_kern == ATTACK_KERN_COMBI)
5278       {
5279         run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5280       }
5281       */
5282     }
5283   }
5284
5285   device_param->kernel_accel = 0;
5286   device_param->kernel_loops = 0;
5287
5288   myfree (buf);
5289
5290   return NULL;
5291 }
5292
5293 static void *thread_calc (void *p)
5294 {
5295   hc_device_param_t *device_param = (hc_device_param_t *) p;
5296
5297   if (device_param->skipped) return NULL;
5298
5299   const uint attack_mode = data.attack_mode;
5300   const uint attack_kern = data.attack_kern;
5301
5302   if (attack_mode == ATTACK_MODE_BF)
5303   {
5304     while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5305     {
5306       const uint work = get_work (device_param, -1);
5307
5308       if (work == 0) break;
5309
5310       const u64 words_off = device_param->words_off;
5311       const u64 words_fin = words_off + work;
5312
5313       const uint pws_cnt = work;
5314
5315       device_param->pws_cnt = pws_cnt;
5316
5317       if (pws_cnt)
5318       {
5319         run_copy (device_param, pws_cnt);
5320
5321         run_cracker (device_param, pws_cnt);
5322
5323         device_param->pws_cnt = 0;
5324
5325         /*
5326         still required?
5327         run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5328         */
5329       }
5330
5331       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5332
5333       if (data.devices_status == STATUS_CRACKED) break;
5334       if (data.devices_status == STATUS_ABORTED) break;
5335       if (data.devices_status == STATUS_QUIT)    break;
5336       if (data.devices_status == STATUS_BYPASS)  break;
5337
5338       if (data.benchmark == 1) break;
5339
5340       device_param->words_done = words_fin;
5341     }
5342   }
5343   else
5344   {
5345     const uint segment_size = data.segment_size;
5346
5347     char *dictfile = data.dictfile;
5348
5349     if (attack_mode == ATTACK_MODE_COMBI)
5350     {
5351       if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5352       {
5353         dictfile = data.dictfile2;
5354       }
5355     }
5356
5357     FILE *fd = fopen (dictfile, "rb");
5358
5359     if (fd == NULL)
5360     {
5361       log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5362
5363       return NULL;
5364     }
5365
5366     if (attack_mode == ATTACK_MODE_COMBI)
5367     {
5368       const uint combs_mode = data.combs_mode;
5369
5370       if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5371       {
5372         const char *dictfilec = data.dictfile2;
5373
5374         FILE *combs_fp = fopen (dictfilec, "rb");
5375
5376         if (combs_fp == NULL)
5377         {
5378           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5379
5380           fclose (fd);
5381
5382           return NULL;
5383         }
5384
5385         device_param->combs_fp = combs_fp;
5386       }
5387       else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5388       {
5389         const char *dictfilec = data.dictfile;
5390
5391         FILE *combs_fp = fopen (dictfilec, "rb");
5392
5393         if (combs_fp == NULL)
5394         {
5395           log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5396
5397           fclose (fd);
5398
5399           return NULL;
5400         }
5401
5402         device_param->combs_fp = combs_fp;
5403       }
5404     }
5405
5406     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5407
5408     wl_data->buf   = (char *) mymalloc (segment_size);
5409     wl_data->avail = segment_size;
5410     wl_data->incr  = segment_size;
5411     wl_data->cnt   = 0;
5412     wl_data->pos   = 0;
5413
5414     u64 words_cur = 0;
5415
5416     while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5417     {
5418       u64 words_off = 0;
5419       u64 words_fin = 0;
5420
5421       u64 max = -1;
5422
5423       while (max)
5424       {
5425         const uint work = get_work (device_param, max);
5426
5427         if (work == 0) break;
5428
5429         max = 0;
5430
5431         words_off = device_param->words_off;
5432         words_fin = words_off + work;
5433
5434         char *line_buf;
5435         uint  line_len;
5436
5437         for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5438
5439         for ( ; words_cur < words_fin; words_cur++)
5440         {
5441           get_next_word (wl_data, fd, &line_buf, &line_len);
5442
5443           line_len = convert_from_hex (line_buf, line_len);
5444
5445           // post-process rule engine
5446
5447           if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5448           {
5449             char rule_buf_out[BLOCK_SIZE] = { 0 };
5450
5451             int rule_len_out = -1;
5452
5453             if (line_len < BLOCK_SIZE)
5454             {
5455               rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5456             }
5457
5458             if (rule_len_out < 0) continue;
5459
5460             line_buf = rule_buf_out;
5461             line_len = rule_len_out;
5462           }
5463
5464           if (attack_kern == ATTACK_KERN_STRAIGHT)
5465           {
5466             if ((line_len < data.pw_min) || (line_len > data.pw_max))
5467             {
5468               max++;
5469
5470               hc_thread_mutex_lock (mux_counter);
5471
5472               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5473               {
5474                 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5475               }
5476
5477               hc_thread_mutex_unlock (mux_counter);
5478
5479               continue;
5480             }
5481           }
5482           else if (attack_kern == ATTACK_KERN_COMBI)
5483           {
5484             // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5485             // since we still need to combine the plains
5486
5487             if (line_len > data.pw_max)
5488             {
5489               max++;
5490
5491               hc_thread_mutex_lock (mux_counter);
5492
5493               for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5494               {
5495                 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5496               }
5497
5498               hc_thread_mutex_unlock (mux_counter);
5499
5500               continue;
5501             }
5502           }
5503
5504           pw_add (device_param, (u8 *) line_buf, line_len);
5505
5506           if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5507
5508           if (data.devices_status == STATUS_CRACKED) break;
5509           if (data.devices_status == STATUS_ABORTED) break;
5510           if (data.devices_status == STATUS_QUIT)    break;
5511           if (data.devices_status == STATUS_BYPASS)  break;
5512         }
5513
5514         if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5515
5516         if (data.devices_status == STATUS_CRACKED) break;
5517         if (data.devices_status == STATUS_ABORTED) break;
5518         if (data.devices_status == STATUS_QUIT)    break;
5519         if (data.devices_status == STATUS_BYPASS)  break;
5520       }
5521
5522       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5523
5524       if (data.devices_status == STATUS_CRACKED) break;
5525       if (data.devices_status == STATUS_ABORTED) break;
5526       if (data.devices_status == STATUS_QUIT)    break;
5527       if (data.devices_status == STATUS_BYPASS)  break;
5528
5529       //
5530       // flush
5531       //
5532
5533       const uint pws_cnt = device_param->pws_cnt;
5534
5535       if (pws_cnt)
5536       {
5537         run_copy (device_param, pws_cnt);
5538
5539         run_cracker (device_param, pws_cnt);
5540
5541         device_param->pws_cnt = 0;
5542
5543         /*
5544         still required?
5545         if (attack_kern == ATTACK_KERN_STRAIGHT)
5546         {
5547           run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5548         }
5549         else if (attack_kern == ATTACK_KERN_COMBI)
5550         {
5551           run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5552         }
5553         */
5554       }
5555
5556       if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5557
5558       if (data.devices_status == STATUS_CRACKED) break;
5559       if (data.devices_status == STATUS_ABORTED) break;
5560       if (data.devices_status == STATUS_QUIT)    break;
5561       if (data.devices_status == STATUS_BYPASS)  break;
5562
5563       if (words_fin == 0) break;
5564
5565       device_param->words_done = words_fin;
5566     }
5567
5568     if (attack_mode == ATTACK_MODE_COMBI)
5569     {
5570       fclose (device_param->combs_fp);
5571     }
5572
5573     free (wl_data->buf);
5574     free (wl_data);
5575
5576     fclose (fd);
5577   }
5578
5579   device_param->kernel_accel = 0;
5580   device_param->kernel_loops = 0;
5581
5582   return NULL;
5583 }
5584
5585 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5586 {
5587   if (!device_param)
5588   {
5589     log_error ("ERROR: %s : Invalid argument", __func__);
5590
5591     exit (-1);
5592   }
5593
5594   salt_t *salt_buf = &data.salts_buf[salt_pos];
5595
5596   device_param->kernel_params_buf32[27] = salt_pos;
5597   device_param->kernel_params_buf32[30] = 1;
5598   device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5599   device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5600   device_param->kernel_params_buf32[33] = 0;
5601   device_param->kernel_params_buf32[34] = 1;
5602
5603   char *dictfile_old = data.dictfile;
5604
5605   const char *weak_hash_check = "weak-hash-check";
5606
5607   data.dictfile = (char *) weak_hash_check;
5608
5609   uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5610
5611   data.kernel_rules_buf[0].cmds[0] = 0;
5612
5613   /**
5614    * run the kernel
5615    */
5616
5617   if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5618   {
5619     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5620   }
5621   else
5622   {
5623     run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5624
5625     uint loop_step = 16;
5626
5627     const uint iter = salt_buf->salt_iter;
5628
5629     for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5630     {
5631       uint loop_left = iter - loop_pos;
5632
5633       loop_left = MIN (loop_left, loop_step);
5634
5635       device_param->kernel_params_buf32[28] = loop_pos;
5636       device_param->kernel_params_buf32[29] = loop_left;
5637
5638       run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5639     }
5640
5641     run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5642   }
5643
5644   /**
5645    * result
5646    */
5647
5648   check_cracked (device_param, salt_pos);
5649
5650   /**
5651    * cleanup
5652    */
5653
5654   device_param->kernel_params_buf32[27] = 0;
5655   device_param->kernel_params_buf32[28] = 0;
5656   device_param->kernel_params_buf32[29] = 0;
5657   device_param->kernel_params_buf32[30] = 0;
5658   device_param->kernel_params_buf32[31] = 0;
5659   device_param->kernel_params_buf32[32] = 0;
5660   device_param->kernel_params_buf32[33] = 0;
5661   device_param->kernel_params_buf32[34] = 0;
5662
5663   data.dictfile = dictfile_old;
5664
5665   data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5666 }
5667
5668 // hlfmt hashcat
5669
5670 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5671 {
5672   if (data.username == 0)
5673   {
5674     *hashbuf_pos = line_buf;
5675     *hashbuf_len = line_len;
5676   }
5677   else
5678   {
5679     char *pos = line_buf;
5680     int   len = line_len;
5681
5682     for (int i = 0; i < line_len; i++, pos++, len--)
5683     {
5684       if (line_buf[i] == data.separator)
5685       {
5686         pos++;
5687
5688         len--;
5689
5690         break;
5691       }
5692     }
5693
5694     *hashbuf_pos = pos;
5695     *hashbuf_len = len;
5696   }
5697 }
5698
5699 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5700 {
5701   char *pos = NULL;
5702   int   len = 0;
5703
5704   int sep_cnt = 0;
5705
5706   for (int i = 0; i < line_len; i++)
5707   {
5708     if (line_buf[i] == data.separator)
5709     {
5710       sep_cnt++;
5711
5712       continue;
5713     }
5714
5715     if (sep_cnt == 0)
5716     {
5717       if (pos == NULL) pos = line_buf + i;
5718
5719       len++;
5720     }
5721   }
5722
5723   *userbuf_pos = pos;
5724   *userbuf_len = len;
5725 }
5726
5727 // hlfmt pwdump
5728
5729 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5730 {
5731   int sep_cnt = 0;
5732
5733   int sep2_len = 0;
5734   int sep3_len = 0;
5735
5736   for (int i = 0; i < line_len; i++)
5737   {
5738     if (line_buf[i] == ':')
5739     {
5740       sep_cnt++;
5741
5742       continue;
5743     }
5744
5745     if (sep_cnt == 2) sep2_len++;
5746     if (sep_cnt == 3) sep3_len++;
5747   }
5748
5749   if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5750
5751   return 0;
5752 }
5753
5754 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5755 {
5756   char *pos = NULL;
5757   int   len = 0;
5758
5759   int sep_cnt = 0;
5760
5761   for (int i = 0; i < line_len; i++)
5762   {
5763     if (line_buf[i] == ':')
5764     {
5765       sep_cnt++;
5766
5767       continue;
5768     }
5769
5770     if (data.hash_mode == 1000)
5771     {
5772       if (sep_cnt == 3)
5773       {
5774         if (pos == NULL) pos = line_buf + i;
5775
5776         len++;
5777       }
5778     }
5779     else if (data.hash_mode == 3000)
5780     {
5781       if (sep_cnt == 2)
5782       {
5783         if (pos == NULL) pos = line_buf + i;
5784
5785         len++;
5786       }
5787     }
5788   }
5789
5790   *hashbuf_pos = pos;
5791   *hashbuf_len = len;
5792 }
5793
5794 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5795 {
5796   char *pos = NULL;
5797   int   len = 0;
5798
5799   int sep_cnt = 0;
5800
5801   for (int i = 0; i < line_len; i++)
5802   {
5803     if (line_buf[i] == ':')
5804     {
5805       sep_cnt++;
5806
5807       continue;
5808     }
5809
5810     if (sep_cnt == 0)
5811     {
5812       if (pos == NULL) pos = line_buf + i;
5813
5814       len++;
5815     }
5816   }
5817
5818   *userbuf_pos = pos;
5819   *userbuf_len = len;
5820 }
5821
5822 // hlfmt passwd
5823
5824 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5825 {
5826   int sep_cnt = 0;
5827
5828   char sep5_first = 0;
5829   char sep6_first = 0;
5830
5831   for (int i = 0; i < line_len; i++)
5832   {
5833     if (line_buf[i] == ':')
5834     {
5835       sep_cnt++;
5836
5837       continue;
5838     }
5839
5840     if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5841     if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5842   }
5843
5844   if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5845
5846   return 0;
5847 }
5848
5849 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5850 {
5851   char *pos = NULL;
5852   int   len = 0;
5853
5854   int sep_cnt = 0;
5855
5856   for (int i = 0; i < line_len; i++)
5857   {
5858     if (line_buf[i] == ':')
5859     {
5860       sep_cnt++;
5861
5862       continue;
5863     }
5864
5865     if (sep_cnt == 1)
5866     {
5867       if (pos == NULL) pos = line_buf + i;
5868
5869       len++;
5870     }
5871   }
5872
5873   *hashbuf_pos = pos;
5874   *hashbuf_len = len;
5875 }
5876
5877 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5878 {
5879   char *pos = NULL;
5880   int   len = 0;
5881
5882   int sep_cnt = 0;
5883
5884   for (int i = 0; i < line_len; i++)
5885   {
5886     if (line_buf[i] == ':')
5887     {
5888       sep_cnt++;
5889
5890       continue;
5891     }
5892
5893     if (sep_cnt == 0)
5894     {
5895       if (pos == NULL) pos = line_buf + i;
5896
5897       len++;
5898     }
5899   }
5900
5901   *userbuf_pos = pos;
5902   *userbuf_len = len;
5903 }
5904
5905 // hlfmt shadow
5906
5907 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5908 {
5909   int sep_cnt = 0;
5910
5911   for (int i = 0; i < line_len; i++)
5912   {
5913     if (line_buf[i] == ':') sep_cnt++;
5914   }
5915
5916   if (sep_cnt == 8) return 1;
5917
5918   return 0;
5919 }
5920
5921 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5922 {
5923   hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5924 }
5925
5926 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5927 {
5928   hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5929 }
5930
5931 // hlfmt main
5932
5933 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5934 {
5935   switch (hashfile_format)
5936   {
5937     case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5938     case HLFMT_PWDUMP:  hlfmt_hash_pwdump  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5939     case HLFMT_PASSWD:  hlfmt_hash_passwd  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5940     case HLFMT_SHADOW:  hlfmt_hash_shadow  (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5941   }
5942 }
5943
5944 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5945 {
5946   switch (hashfile_format)
5947   {
5948     case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5949     case HLFMT_PWDUMP:  hlfmt_user_pwdump  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5950     case HLFMT_PASSWD:  hlfmt_user_passwd  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5951     case HLFMT_SHADOW:  hlfmt_user_shadow  (line_buf, line_len, userbuf_pos, userbuf_len); break;
5952   }
5953 }
5954
5955 char *strhlfmt (const uint hashfile_format)
5956 {
5957   switch (hashfile_format)
5958   {
5959     case HLFMT_HASHCAT:  return ((char *) HLFMT_TEXT_HASHCAT);  break;
5960     case HLFMT_PWDUMP:   return ((char *) HLFMT_TEXT_PWDUMP);   break;
5961     case HLFMT_PASSWD:   return ((char *) HLFMT_TEXT_PASSWD);   break;
5962     case HLFMT_SHADOW:   return ((char *) HLFMT_TEXT_SHADOW);   break;
5963     case HLFMT_DCC:      return ((char *) HLFMT_TEXT_DCC);      break;
5964     case HLFMT_DCC2:     return ((char *) HLFMT_TEXT_DCC2);     break;
5965     case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5966     case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5967     case HLFMT_NSLDAP:   return ((char *) HLFMT_TEXT_NSLDAP);   break;
5968     case HLFMT_NSLDAPS:  return ((char *) HLFMT_TEXT_NSLDAPS);  break;
5969   }
5970
5971   return ((char *) "Unknown");
5972 }
5973
5974 static uint hlfmt_detect (FILE *fp, uint max_check)
5975 {
5976   // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5977
5978   if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5979   if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5980
5981   uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5982
5983   uint num_check = 0;
5984
5985   char *line_buf = (char *) mymalloc (HCBUFSIZ);
5986
5987   while (!feof (fp))
5988   {
5989     int line_len = fgetl (fp, line_buf);
5990
5991     if (line_len == 0) continue;
5992
5993     if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5994     if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5995     if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5996
5997     if (num_check == max_check) break;
5998
5999     num_check++;
6000   }
6001
6002   myfree (line_buf);
6003
6004   uint hashlist_format = HLFMT_HASHCAT;
6005
6006   for (int i = 1; i < HLFMTS_CNT; i++)
6007   {
6008     if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
6009
6010     hashlist_format = i;
6011   }
6012
6013   free (formats_cnt);
6014
6015   return hashlist_format;
6016 }
6017
6018 /**
6019  * some further helper function
6020  */
6021
6022 // wrapper around mymalloc for ADL
6023
6024 #if defined(HAVE_HWMON)
6025 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
6026 {
6027   return mymalloc (iSize);
6028 }
6029 #endif
6030
6031 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)
6032 {
6033   u64 collisions = 0;
6034
6035   const uint dgst_pos0 = data.dgst_pos0;
6036   const uint dgst_pos1 = data.dgst_pos1;
6037   const uint dgst_pos2 = data.dgst_pos2;
6038   const uint dgst_pos3 = data.dgst_pos3;
6039
6040   memset (bitmap_a, 0, bitmap_size);
6041   memset (bitmap_b, 0, bitmap_size);
6042   memset (bitmap_c, 0, bitmap_size);
6043   memset (bitmap_d, 0, bitmap_size);
6044
6045   for (uint i = 0; i < digests_cnt; i++)
6046   {
6047     uint *digest_ptr = (uint *) digests_buf_ptr;
6048
6049     digests_buf_ptr += dgst_size;
6050
6051     const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
6052     const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
6053     const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
6054     const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
6055
6056     const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
6057     const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
6058     const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
6059     const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
6060
6061     if (bitmap_a[idx0] & val0) collisions++;
6062     if (bitmap_b[idx1] & val1) collisions++;
6063     if (bitmap_c[idx2] & val2) collisions++;
6064     if (bitmap_d[idx3] & val3) collisions++;
6065
6066     bitmap_a[idx0] |= val0;
6067     bitmap_b[idx1] |= val1;
6068     bitmap_c[idx2] |= val2;
6069     bitmap_d[idx3] |= val3;
6070
6071     if (collisions >= collisions_max) return 0x7fffffff;
6072   }
6073
6074   return collisions;
6075 }
6076
6077 /**
6078  * main
6079  */
6080
6081 #ifdef WIN
6082 void SetConsoleWindowSize (const int x)
6083 {
6084   HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
6085
6086   if (h == INVALID_HANDLE_VALUE) return;
6087
6088   CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
6089
6090   if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
6091
6092   SMALL_RECT *sr = &bufferInfo.srWindow;
6093
6094   sr->Right = MAX (sr->Right, x - 1);
6095
6096   COORD co;
6097
6098   co.X = sr->Right + 1;
6099   co.Y = 9999;
6100
6101   if (!SetConsoleScreenBufferSize (h, co)) return;
6102
6103   if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
6104 }
6105 #endif
6106
6107 int main (int argc, char **argv)
6108 {
6109   #ifdef WIN
6110   SetConsoleWindowSize (132);
6111   #endif
6112
6113   /**
6114    * To help users a bit
6115    */
6116
6117   char *compute = getenv ("COMPUTE");
6118
6119   if (compute)
6120   {
6121     static char display[100];
6122
6123     snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
6124
6125     putenv (display);
6126   }
6127   else
6128   {
6129     if (getenv ("DISPLAY") == NULL)
6130       putenv ((char *) "DISPLAY=:0");
6131   }
6132
6133   if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
6134     putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
6135
6136   if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
6137     putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
6138
6139   if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
6140     putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
6141
6142   if (getenv ("CUDA_CACHE_DISABLE") == NULL)
6143     putenv ((char *) "CUDA_CACHE_DISABLE=1");
6144
6145   if (getenv ("POCL_KERNEL_CACHE") == NULL)
6146     putenv ((char *) "POCL_KERNEL_CACHE=0");
6147
6148   umask (077);
6149
6150   /**
6151    * There's some buggy OpenCL runtime that do not support -I.
6152    * A workaround is to chdir() to the OpenCL folder,
6153    * then compile the kernels,
6154    * then chdir() back to where we came from so we need to save it first
6155    */
6156
6157   char cwd[1024];
6158
6159   if (getcwd (cwd, sizeof (cwd) - 1) == NULL)
6160   {
6161     log_error ("ERROR: getcwd(): %s", strerror (errno));
6162
6163     return -1;
6164   }
6165
6166   /**
6167    * Real init
6168    */
6169
6170   memset (&data, 0, sizeof (hc_global_data_t));
6171
6172   time_t proc_start;
6173
6174   time (&proc_start);
6175
6176   data.proc_start = proc_start;
6177
6178   int    myargc = argc;
6179   char **myargv = argv;
6180
6181   hc_thread_mutex_init (mux_dispatcher);
6182   hc_thread_mutex_init (mux_counter);
6183   hc_thread_mutex_init (mux_display);
6184   hc_thread_mutex_init (mux_adl);
6185
6186   /**
6187    * commandline parameters
6188    */
6189
6190   uint  usage                     = USAGE;
6191   uint  version                   = VERSION;
6192   uint  quiet                     = QUIET;
6193   uint  benchmark                 = BENCHMARK;
6194   uint  stdout_flag               = STDOUT_FLAG;
6195   uint  show                      = SHOW;
6196   uint  left                      = LEFT;
6197   uint  username                  = USERNAME;
6198   uint  remove                    = REMOVE;
6199   uint  remove_timer              = REMOVE_TIMER;
6200   u64   skip                      = SKIP;
6201   u64   limit                     = LIMIT;
6202   uint  keyspace                  = KEYSPACE;
6203   uint  potfile_disable           = POTFILE_DISABLE;
6204   char *potfile_path              = NULL;
6205   uint  debug_mode                = DEBUG_MODE;
6206   char *debug_file                = NULL;
6207   char *induction_dir             = NULL;
6208   char *outfile_check_dir         = NULL;
6209   uint  force                     = FORCE;
6210   uint  runtime                   = RUNTIME;
6211   uint  hash_mode                 = HASH_MODE;
6212   uint  attack_mode               = ATTACK_MODE;
6213   uint  markov_disable            = MARKOV_DISABLE;
6214   uint  markov_classic            = MARKOV_CLASSIC;
6215   uint  markov_threshold          = MARKOV_THRESHOLD;
6216   char *markov_hcstat             = NULL;
6217   char *outfile                   = NULL;
6218   uint  outfile_format            = OUTFILE_FORMAT;
6219   uint  outfile_autohex           = OUTFILE_AUTOHEX;
6220   uint  outfile_check_timer       = OUTFILE_CHECK_TIMER;
6221   uint  restore                   = RESTORE;
6222   uint  restore_timer             = RESTORE_TIMER;
6223   uint  restore_disable           = RESTORE_DISABLE;
6224   uint  status                    = STATUS;
6225   uint  status_timer              = STATUS_TIMER;
6226   uint  machine_readable          = MACHINE_READABLE;
6227   uint  loopback                  = LOOPBACK;
6228   uint  weak_hash_threshold       = WEAK_HASH_THRESHOLD;
6229   char *session                   = NULL;
6230   uint  hex_charset               = HEX_CHARSET;
6231   uint  hex_salt                  = HEX_SALT;
6232   uint  hex_wordlist              = HEX_WORDLIST;
6233   uint  rp_gen                    = RP_GEN;
6234   uint  rp_gen_func_min           = RP_GEN_FUNC_MIN;
6235   uint  rp_gen_func_max           = RP_GEN_FUNC_MAX;
6236   uint  rp_gen_seed               = RP_GEN_SEED;
6237   char *rule_buf_l                = (char *) RULE_BUF_L;
6238   char *rule_buf_r                = (char *) RULE_BUF_R;
6239   uint  increment                 = INCREMENT;
6240   uint  increment_min             = INCREMENT_MIN;
6241   uint  increment_max             = INCREMENT_MAX;
6242   char *cpu_affinity              = NULL;
6243   OCL_PTR *ocl                    = NULL;
6244   char *opencl_devices            = NULL;
6245   char *opencl_platforms          = NULL;
6246   char *opencl_device_types       = NULL;
6247   uint  opencl_vector_width       = OPENCL_VECTOR_WIDTH;
6248   char *truecrypt_keyfiles        = NULL;
6249   char *veracrypt_keyfiles        = NULL;
6250   uint  veracrypt_pim             = 0;
6251   uint  workload_profile          = WORKLOAD_PROFILE;
6252   uint  kernel_accel              = KERNEL_ACCEL;
6253   uint  kernel_loops              = KERNEL_LOOPS;
6254   uint  nvidia_spin_damp          = NVIDIA_SPIN_DAMP;
6255   uint  gpu_temp_disable          = GPU_TEMP_DISABLE;
6256   #ifdef HAVE_HWMON
6257   uint  gpu_temp_abort            = GPU_TEMP_ABORT;
6258   uint  gpu_temp_retain           = GPU_TEMP_RETAIN;
6259   uint  powertune_enable          = POWERTUNE_ENABLE;
6260   #endif
6261   uint  logfile_disable           = LOGFILE_DISABLE;
6262   uint  segment_size              = SEGMENT_SIZE;
6263   uint  scrypt_tmto               = SCRYPT_TMTO;
6264   char  separator                 = SEPARATOR;
6265   uint  bitmap_min                = BITMAP_MIN;
6266   uint  bitmap_max                = BITMAP_MAX;
6267   char *custom_charset_1          = NULL;
6268   char *custom_charset_2          = NULL;
6269   char *custom_charset_3          = NULL;
6270   char *custom_charset_4          = NULL;
6271
6272   #define IDX_HELP                      'h'
6273   #define IDX_VERSION                   'V'
6274   #define IDX_VERSION_LOWER             'v'
6275   #define IDX_QUIET                     0xff02
6276   #define IDX_SHOW                      0xff03
6277   #define IDX_LEFT                      0xff04
6278   #define IDX_REMOVE                    0xff05
6279   #define IDX_REMOVE_TIMER              0xff37
6280   #define IDX_SKIP                      's'
6281   #define IDX_LIMIT                     'l'
6282   #define IDX_KEYSPACE                  0xff35
6283   #define IDX_POTFILE_DISABLE           0xff06
6284   #define IDX_POTFILE_PATH              0xffe0
6285   #define IDX_DEBUG_MODE                0xff43
6286   #define IDX_DEBUG_FILE                0xff44
6287   #define IDX_INDUCTION_DIR             0xff46
6288   #define IDX_OUTFILE_CHECK_DIR         0xff47
6289   #define IDX_USERNAME                  0xff07
6290   #define IDX_FORCE                     0xff08
6291   #define IDX_RUNTIME                   0xff09
6292   #define IDX_BENCHMARK                 'b'
6293   #define IDX_STDOUT_FLAG               0xff77
6294   #define IDX_HASH_MODE                 'm'
6295   #define IDX_ATTACK_MODE               'a'
6296   #define IDX_RP_FILE                   'r'
6297   #define IDX_RP_GEN                    'g'
6298   #define IDX_RP_GEN_FUNC_MIN           0xff10
6299   #define IDX_RP_GEN_FUNC_MAX           0xff11
6300   #define IDX_RP_GEN_SEED               0xff34
6301   #define IDX_RULE_BUF_L                'j'
6302   #define IDX_RULE_BUF_R                'k'
6303   #define IDX_INCREMENT                 'i'
6304   #define IDX_INCREMENT_MIN             0xff12
6305   #define IDX_INCREMENT_MAX             0xff13
6306   #define IDX_OUTFILE                   'o'
6307   #define IDX_OUTFILE_FORMAT            0xff14
6308   #define IDX_OUTFILE_AUTOHEX_DISABLE   0xff39
6309   #define IDX_OUTFILE_CHECK_TIMER       0xff45
6310   #define IDX_RESTORE                   0xff15
6311   #define IDX_RESTORE_DISABLE           0xff27
6312   #define IDX_STATUS                    0xff17
6313   #define IDX_STATUS_TIMER              0xff18
6314   #define IDX_MACHINE_READABLE          0xff50
6315   #define IDX_LOOPBACK                  0xff38
6316   #define IDX_WEAK_HASH_THRESHOLD       0xff42
6317   #define IDX_SESSION                   0xff19
6318   #define IDX_HEX_CHARSET               0xff20
6319   #define IDX_HEX_SALT                  0xff21
6320   #define IDX_HEX_WORDLIST              0xff40
6321   #define IDX_MARKOV_DISABLE            0xff22
6322   #define IDX_MARKOV_CLASSIC            0xff23
6323   #define IDX_MARKOV_THRESHOLD          't'
6324   #define IDX_MARKOV_HCSTAT             0xff24
6325   #define IDX_CPU_AFFINITY              0xff25
6326   #define IDX_OPENCL_DEVICES            'd'
6327   #define IDX_OPENCL_PLATFORMS          0xff72
6328   #define IDX_OPENCL_DEVICE_TYPES       'D'
6329   #define IDX_OPENCL_VECTOR_WIDTH       0xff74
6330   #define IDX_WORKLOAD_PROFILE          'w'
6331   #define IDX_KERNEL_ACCEL              'n'
6332   #define IDX_KERNEL_LOOPS              'u'
6333   #define IDX_NVIDIA_SPIN_DAMP          0xff79
6334   #define IDX_GPU_TEMP_DISABLE          0xff29
6335   #define IDX_GPU_TEMP_ABORT            0xff30
6336   #define IDX_GPU_TEMP_RETAIN           0xff31
6337   #define IDX_POWERTUNE_ENABLE          0xff41
6338   #define IDX_LOGFILE_DISABLE           0xff51
6339   #define IDX_TRUECRYPT_KEYFILES        0xff52
6340   #define IDX_VERACRYPT_KEYFILES        0xff53
6341   #define IDX_VERACRYPT_PIM             0xff54
6342   #define IDX_SCRYPT_TMTO               0xff61
6343   #define IDX_SEGMENT_SIZE              'c'
6344   #define IDX_SEPARATOR                 'p'
6345   #define IDX_BITMAP_MIN                0xff70
6346   #define IDX_BITMAP_MAX                0xff71
6347   #define IDX_CUSTOM_CHARSET_1          '1'
6348   #define IDX_CUSTOM_CHARSET_2          '2'
6349   #define IDX_CUSTOM_CHARSET_3          '3'
6350   #define IDX_CUSTOM_CHARSET_4          '4'
6351
6352   char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6353
6354   struct option long_options[] =
6355   {
6356     {"help",                      no_argument,       0, IDX_HELP},
6357     {"version",                   no_argument,       0, IDX_VERSION},
6358     {"quiet",                     no_argument,       0, IDX_QUIET},
6359     {"show",                      no_argument,       0, IDX_SHOW},
6360     {"left",                      no_argument,       0, IDX_LEFT},
6361     {"username",                  no_argument,       0, IDX_USERNAME},
6362     {"remove",                    no_argument,       0, IDX_REMOVE},
6363     {"remove-timer",              required_argument, 0, IDX_REMOVE_TIMER},
6364     {"skip",                      required_argument, 0, IDX_SKIP},
6365     {"limit",                     required_argument, 0, IDX_LIMIT},
6366     {"keyspace",                  no_argument,       0, IDX_KEYSPACE},
6367     {"potfile-disable",           no_argument,       0, IDX_POTFILE_DISABLE},
6368     {"potfile-path",              required_argument, 0, IDX_POTFILE_PATH},
6369     {"debug-mode",                required_argument, 0, IDX_DEBUG_MODE},
6370     {"debug-file",                required_argument, 0, IDX_DEBUG_FILE},
6371     {"induction-dir",             required_argument, 0, IDX_INDUCTION_DIR},
6372     {"outfile-check-dir",         required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6373     {"force",                     no_argument,       0, IDX_FORCE},
6374     {"benchmark",                 no_argument,       0, IDX_BENCHMARK},
6375     {"stdout",                    no_argument,       0, IDX_STDOUT_FLAG},
6376     {"restore",                   no_argument,       0, IDX_RESTORE},
6377     {"restore-disable",           no_argument,       0, IDX_RESTORE_DISABLE},
6378     {"status",                    no_argument,       0, IDX_STATUS},
6379     {"status-timer",              required_argument, 0, IDX_STATUS_TIMER},
6380     {"machine-readable",          no_argument,       0, IDX_MACHINE_READABLE},
6381     {"loopback",                  no_argument,       0, IDX_LOOPBACK},
6382     {"weak-hash-threshold",       required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6383     {"session",                   required_argument, 0, IDX_SESSION},
6384     {"runtime",                   required_argument, 0, IDX_RUNTIME},
6385     {"generate-rules",            required_argument, 0, IDX_RP_GEN},
6386     {"generate-rules-func-min",   required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6387     {"generate-rules-func-max",   required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6388     {"generate-rules-seed",       required_argument, 0, IDX_RP_GEN_SEED},
6389     {"rule-left",                 required_argument, 0, IDX_RULE_BUF_L},
6390     {"rule-right",                required_argument, 0, IDX_RULE_BUF_R},
6391     {"hash-type",                 required_argument, 0, IDX_HASH_MODE},
6392     {"attack-mode",               required_argument, 0, IDX_ATTACK_MODE},
6393     {"rules-file",                required_argument, 0, IDX_RP_FILE},
6394     {"outfile",                   required_argument, 0, IDX_OUTFILE},
6395     {"outfile-format",            required_argument, 0, IDX_OUTFILE_FORMAT},
6396     {"outfile-autohex-disable",   no_argument,       0, IDX_OUTFILE_AUTOHEX_DISABLE},
6397     {"outfile-check-timer",       required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6398     {"hex-charset",               no_argument,       0, IDX_HEX_CHARSET},
6399     {"hex-salt",                  no_argument,       0, IDX_HEX_SALT},
6400     {"hex-wordlist",              no_argument,       0, IDX_HEX_WORDLIST},
6401     {"markov-disable",            no_argument,       0, IDX_MARKOV_DISABLE},
6402     {"markov-classic",            no_argument,       0, IDX_MARKOV_CLASSIC},
6403     {"markov-threshold",          required_argument, 0, IDX_MARKOV_THRESHOLD},
6404     {"markov-hcstat",             required_argument, 0, IDX_MARKOV_HCSTAT},
6405     {"cpu-affinity",              required_argument, 0, IDX_CPU_AFFINITY},
6406     {"opencl-devices",            required_argument, 0, IDX_OPENCL_DEVICES},
6407     {"opencl-platforms",          required_argument, 0, IDX_OPENCL_PLATFORMS},
6408     {"opencl-device-types",       required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6409     {"opencl-vector-width",       required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6410     {"workload-profile",          required_argument, 0, IDX_WORKLOAD_PROFILE},
6411     {"kernel-accel",              required_argument, 0, IDX_KERNEL_ACCEL},
6412     {"kernel-loops",              required_argument, 0, IDX_KERNEL_LOOPS},
6413     {"nvidia-spin-damp",          required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6414     {"gpu-temp-disable",          no_argument,       0, IDX_GPU_TEMP_DISABLE},
6415     #ifdef HAVE_HWMON
6416     {"gpu-temp-abort",            required_argument, 0, IDX_GPU_TEMP_ABORT},
6417     {"gpu-temp-retain",           required_argument, 0, IDX_GPU_TEMP_RETAIN},
6418     {"powertune-enable",          no_argument,       0, IDX_POWERTUNE_ENABLE},
6419     #endif // HAVE_HWMON
6420     {"logfile-disable",           no_argument,       0, IDX_LOGFILE_DISABLE},
6421     {"truecrypt-keyfiles",        required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6422     {"veracrypt-keyfiles",        required_argument, 0, IDX_VERACRYPT_KEYFILES},
6423     {"veracrypt-pim",             required_argument, 0, IDX_VERACRYPT_PIM},
6424     {"segment-size",              required_argument, 0, IDX_SEGMENT_SIZE},
6425     {"scrypt-tmto",               required_argument, 0, IDX_SCRYPT_TMTO},
6426     {"seperator",                 required_argument, 0, IDX_SEPARATOR},
6427     {"separator",                 required_argument, 0, IDX_SEPARATOR},
6428     {"bitmap-min",                required_argument, 0, IDX_BITMAP_MIN},
6429     {"bitmap-max",                required_argument, 0, IDX_BITMAP_MAX},
6430     {"increment",                 no_argument,       0, IDX_INCREMENT},
6431     {"increment-min",             required_argument, 0, IDX_INCREMENT_MIN},
6432     {"increment-max",             required_argument, 0, IDX_INCREMENT_MAX},
6433     {"custom-charset1",           required_argument, 0, IDX_CUSTOM_CHARSET_1},
6434     {"custom-charset2",           required_argument, 0, IDX_CUSTOM_CHARSET_2},
6435     {"custom-charset3",           required_argument, 0, IDX_CUSTOM_CHARSET_3},
6436     {"custom-charset4",           required_argument, 0, IDX_CUSTOM_CHARSET_4},
6437     {0, 0, 0, 0}
6438   };
6439
6440   uint rp_files_cnt = 0;
6441
6442   char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6443
6444   int option_index = 0;
6445   int c = -1;
6446
6447   optind = 1;
6448   optopt = 0;
6449
6450   while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6451   {
6452     switch (c)
6453     {
6454       case IDX_HELP:          usage   = 1;      break;
6455       case IDX_VERSION:
6456       case IDX_VERSION_LOWER: version = 1;      break;
6457       case IDX_RESTORE:       restore = 1;      break;
6458       case IDX_SESSION:       session = optarg; break;
6459       case IDX_SHOW:          show    = 1;      break;
6460       case IDX_LEFT:          left    = 1;      break;
6461       case '?':               return -1;
6462     }
6463   }
6464
6465   if (optopt != 0)
6466   {
6467     log_error ("ERROR: Invalid argument specified");
6468
6469     return -1;
6470   }
6471
6472   /**
6473    * exit functions
6474    */
6475
6476   if (version)
6477   {
6478     log_info ("%s", VERSION_TAG);
6479
6480     return 0;
6481   }
6482
6483   if (usage)
6484   {
6485     usage_big_print (PROGNAME);
6486
6487     return 0;
6488   }
6489
6490   /**
6491    * session needs to be set, always!
6492    */
6493
6494   if (session == NULL) session = (char *) PROGNAME;
6495
6496   /**
6497    * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6498    */
6499
6500   char *exec_path = get_exec_path ();
6501
6502
6503   #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
6504
6505   char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6506   char *resolved_exec_path      = realpath (exec_path, NULL);
6507
6508   if (resolved_install_folder == NULL)
6509   {
6510     log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6511
6512     return -1;
6513   }
6514
6515   if (resolved_exec_path == NULL)
6516   {
6517     log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6518
6519     return -1;
6520   }
6521
6522   char *install_dir = get_install_dir (resolved_exec_path);
6523   char *profile_dir = NULL;
6524   char *session_dir = NULL;
6525   char *shared_dir  = NULL;
6526
6527   if (strcmp (install_dir, resolved_install_folder) == 0)
6528   {
6529     struct passwd *pw = getpwuid (getuid ());
6530
6531     const char *homedir = pw->pw_dir;
6532
6533     profile_dir = get_profile_dir (homedir);
6534     session_dir = get_session_dir (profile_dir);
6535     shared_dir  = strdup (SHARED_FOLDER);
6536
6537     mkdir (profile_dir, 0700);
6538     mkdir (session_dir, 0700);
6539   }
6540   else
6541   {
6542     profile_dir = install_dir;
6543     session_dir = install_dir;
6544     shared_dir  = install_dir;
6545   }
6546
6547   myfree (resolved_install_folder);
6548   myfree (resolved_exec_path);
6549
6550   #else
6551
6552   char *install_dir = get_install_dir (exec_path);
6553   char *profile_dir = install_dir;
6554   char *session_dir = install_dir;
6555   char *shared_dir  = install_dir;
6556
6557   #endif
6558
6559   data.install_dir = install_dir;
6560   data.profile_dir = profile_dir;
6561   data.session_dir = session_dir;
6562   data.shared_dir  = shared_dir;
6563
6564   myfree (exec_path);
6565
6566   /**
6567    * kernel cache, we need to make sure folder exist
6568    */
6569
6570   int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6571
6572   char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6573
6574   snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6575
6576   mkdir (kernels_folder, 0700);
6577
6578   myfree (kernels_folder);
6579
6580   /**
6581    * session
6582    */
6583
6584   size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6585
6586   data.session = session;
6587
6588   char *eff_restore_file = (char *) mymalloc (session_size);
6589   char *new_restore_file = (char *) mymalloc (session_size);
6590
6591   snprintf (eff_restore_file, session_size - 1, "%s/%s.restore",     data.session_dir, session);
6592   snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6593
6594   data.eff_restore_file = eff_restore_file;
6595   data.new_restore_file = new_restore_file;
6596
6597   if (((show == 1) || (left == 1)) && (restore == 1))
6598   {
6599     if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6600     else           log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6601
6602     return -1;
6603   }
6604
6605   // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6606   if ((show == 1) || (left == 1))
6607   {
6608     restore_disable = 1;
6609
6610     restore = 0;
6611   }
6612
6613   data.restore_disable = restore_disable;
6614
6615   restore_data_t *rd = init_restore (argc, argv);
6616
6617   data.rd = rd;
6618
6619   /**
6620    * restore file
6621    */
6622
6623   if (restore == 1)
6624   {
6625     read_restore (eff_restore_file, rd);
6626
6627     if (rd->version_bin < RESTORE_MIN)
6628     {
6629       log_error ("ERROR: Incompatible restore-file version");
6630
6631       return -1;
6632     }
6633
6634     myargc = rd->argc;
6635     myargv = rd->argv;
6636
6637     #ifdef _POSIX
6638     rd->pid = getpid ();
6639     #elif _WIN
6640     rd->pid = GetCurrentProcessId ();
6641     #endif
6642   }
6643
6644   uint hash_mode_chgd           = 0;
6645   uint runtime_chgd             = 0;
6646   uint kernel_loops_chgd        = 0;
6647   uint kernel_accel_chgd        = 0;
6648   uint nvidia_spin_damp_chgd    = 0;
6649   uint attack_mode_chgd         = 0;
6650   uint outfile_format_chgd      = 0;
6651   uint rp_gen_seed_chgd         = 0;
6652   uint remove_timer_chgd        = 0;
6653   uint increment_min_chgd       = 0;
6654   uint increment_max_chgd       = 0;
6655   uint workload_profile_chgd    = 0;
6656   uint opencl_vector_width_chgd = 0;
6657
6658   optind = 1;
6659   optopt = 0;
6660   option_index = 0;
6661
6662   while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6663   {
6664     switch (c)
6665     {
6666     //case IDX_HELP:                      usage                     = 1;              break;
6667     //case IDX_VERSION:                   version                   = 1;              break;
6668     //case IDX_RESTORE:                   restore                   = 1;              break;
6669       case IDX_QUIET:                     quiet                     = 1;              break;
6670     //case IDX_SHOW:                      show                      = 1;              break;
6671       case IDX_SHOW:                                                                  break;
6672     //case IDX_LEFT:                      left                      = 1;              break;
6673       case IDX_LEFT:                                                                  break;
6674       case IDX_USERNAME:                  username                  = 1;              break;
6675       case IDX_REMOVE:                    remove                    = 1;              break;
6676       case IDX_REMOVE_TIMER:              remove_timer              = atoi (optarg);
6677                                           remove_timer_chgd         = 1;              break;
6678       case IDX_POTFILE_DISABLE:           potfile_disable           = 1;              break;
6679       case IDX_POTFILE_PATH:              potfile_path              = optarg;         break;
6680       case IDX_DEBUG_MODE:                debug_mode                = atoi (optarg);  break;
6681       case IDX_DEBUG_FILE:                debug_file                = optarg;         break;
6682       case IDX_INDUCTION_DIR:             induction_dir             = optarg;         break;
6683       case IDX_OUTFILE_CHECK_DIR:         outfile_check_dir         = optarg;         break;
6684       case IDX_FORCE:                     force                     = 1;              break;
6685       case IDX_SKIP:                      skip                      = atoll (optarg); break;
6686       case IDX_LIMIT:                     limit                     = atoll (optarg); break;
6687       case IDX_KEYSPACE:                  keyspace                  = 1;              break;
6688       case IDX_BENCHMARK:                 benchmark                 = 1;              break;
6689       case IDX_STDOUT_FLAG:               stdout_flag               = 1;              break;
6690       case IDX_RESTORE:                                                               break;
6691       case IDX_RESTORE_DISABLE:           restore_disable           = 1;              break;
6692       case IDX_STATUS:                    status                    = 1;              break;
6693       case IDX_STATUS_TIMER:              status_timer              = atoi (optarg);  break;
6694       case IDX_MACHINE_READABLE:          machine_readable          = 1;              break;
6695       case IDX_LOOPBACK:                  loopback                  = 1;              break;
6696       case IDX_WEAK_HASH_THRESHOLD:       weak_hash_threshold       = atoi (optarg);  break;
6697     //case IDX_SESSION:                   session                   = optarg;         break;
6698       case IDX_SESSION:                                                               break;
6699       case IDX_HASH_MODE:                 hash_mode                 = atoi (optarg);
6700                                           hash_mode_chgd            = 1;              break;
6701       case IDX_RUNTIME:                   runtime                   = atoi (optarg);
6702                                           runtime_chgd              = 1;              break;
6703       case IDX_ATTACK_MODE:               attack_mode               = atoi (optarg);
6704                                           attack_mode_chgd          = 1;              break;
6705       case IDX_RP_FILE:                   rp_files[rp_files_cnt++]  = optarg;         break;
6706       case IDX_RP_GEN:                    rp_gen                    = atoi (optarg);  break;
6707       case IDX_RP_GEN_FUNC_MIN:           rp_gen_func_min           = atoi (optarg);  break;
6708       case IDX_RP_GEN_FUNC_MAX:           rp_gen_func_max           = atoi (optarg);  break;
6709       case IDX_RP_GEN_SEED:               rp_gen_seed               = atoi (optarg);
6710                                           rp_gen_seed_chgd          = 1;              break;
6711       case IDX_RULE_BUF_L:                rule_buf_l                = optarg;         break;
6712       case IDX_RULE_BUF_R:                rule_buf_r                = optarg;         break;
6713       case IDX_MARKOV_DISABLE:            markov_disable            = 1;              break;
6714       case IDX_MARKOV_CLASSIC:            markov_classic            = 1;              break;
6715       case IDX_MARKOV_THRESHOLD:          markov_threshold          = atoi (optarg);  break;
6716       case IDX_MARKOV_HCSTAT:             markov_hcstat             = optarg;         break;
6717       case IDX_OUTFILE:                   outfile                   = optarg;         break;
6718       case IDX_OUTFILE_FORMAT:            outfile_format            = atoi (optarg);
6719                                           outfile_format_chgd       = 1;              break;
6720       case IDX_OUTFILE_AUTOHEX_DISABLE:   outfile_autohex           = 0;              break;
6721       case IDX_OUTFILE_CHECK_TIMER:       outfile_check_timer       = atoi (optarg);  break;
6722       case IDX_HEX_CHARSET:               hex_charset               = 1;              break;
6723       case IDX_HEX_SALT:                  hex_salt                  = 1;              break;
6724       case IDX_HEX_WORDLIST:              hex_wordlist              = 1;              break;
6725       case IDX_CPU_AFFINITY:              cpu_affinity              = optarg;         break;
6726       case IDX_OPENCL_DEVICES:            opencl_devices            = optarg;         break;
6727       case IDX_OPENCL_PLATFORMS:          opencl_platforms          = optarg;         break;
6728       case IDX_OPENCL_DEVICE_TYPES:       opencl_device_types       = optarg;         break;
6729       case IDX_OPENCL_VECTOR_WIDTH:       opencl_vector_width       = atoi (optarg);
6730                                           opencl_vector_width_chgd  = 1;              break;
6731       case IDX_WORKLOAD_PROFILE:          workload_profile          = atoi (optarg);
6732                                           workload_profile_chgd     = 1;              break;
6733       case IDX_KERNEL_ACCEL:              kernel_accel              = atoi (optarg);
6734                                           kernel_accel_chgd         = 1;              break;
6735       case IDX_KERNEL_LOOPS:              kernel_loops              = atoi (optarg);
6736                                           kernel_loops_chgd         = 1;              break;
6737       case IDX_NVIDIA_SPIN_DAMP:          nvidia_spin_damp          = atoi (optarg);
6738                                           nvidia_spin_damp_chgd     = 1;              break;
6739       case IDX_GPU_TEMP_DISABLE:          gpu_temp_disable          = 1;              break;
6740       #ifdef HAVE_HWMON
6741       case IDX_GPU_TEMP_ABORT:            gpu_temp_abort            = atoi (optarg);  break;
6742       case IDX_GPU_TEMP_RETAIN:           gpu_temp_retain           = atoi (optarg);  break;
6743       case IDX_POWERTUNE_ENABLE:          powertune_enable          = 1;              break;
6744       #endif // HAVE_HWMON
6745       case IDX_LOGFILE_DISABLE:           logfile_disable           = 1;              break;
6746       case IDX_TRUECRYPT_KEYFILES:        truecrypt_keyfiles        = optarg;         break;
6747       case IDX_VERACRYPT_KEYFILES:        veracrypt_keyfiles        = optarg;         break;
6748       case IDX_VERACRYPT_PIM:             veracrypt_pim             = atoi (optarg);  break;
6749       case IDX_SEGMENT_SIZE:              segment_size              = atoi (optarg);  break;
6750       case IDX_SCRYPT_TMTO:               scrypt_tmto               = atoi (optarg);  break;
6751       case IDX_SEPARATOR:                 separator                 = optarg[0];      break;
6752       case IDX_BITMAP_MIN:                bitmap_min                = atoi (optarg);  break;
6753       case IDX_BITMAP_MAX:                bitmap_max                = atoi (optarg);  break;
6754       case IDX_INCREMENT:                 increment                 = 1;              break;
6755       case IDX_INCREMENT_MIN:             increment_min             = atoi (optarg);
6756                                           increment_min_chgd        = 1;              break;
6757       case IDX_INCREMENT_MAX:             increment_max             = atoi (optarg);
6758                                           increment_max_chgd        = 1;              break;
6759       case IDX_CUSTOM_CHARSET_1:          custom_charset_1          = optarg;         break;
6760       case IDX_CUSTOM_CHARSET_2:          custom_charset_2          = optarg;         break;
6761       case IDX_CUSTOM_CHARSET_3:          custom_charset_3          = optarg;         break;
6762       case IDX_CUSTOM_CHARSET_4:          custom_charset_4          = optarg;         break;
6763
6764       default:
6765         log_error ("ERROR: Invalid argument specified");
6766         return -1;
6767     }
6768   }
6769
6770   if (optopt != 0)
6771   {
6772     log_error ("ERROR: Invalid argument specified");
6773
6774     return -1;
6775   }
6776
6777   /**
6778    * Inform user things getting started,
6779    * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6780    * - we do not need to check algorithm_pos
6781    */
6782
6783   if (quiet == 0)
6784   {
6785     if (benchmark == 1)
6786     {
6787       if (machine_readable == 0)
6788       {
6789         log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6790         log_info ("");
6791       }
6792       else
6793       {
6794         log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6795       }
6796     }
6797     else if (restore == 1)
6798     {
6799       log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6800       log_info ("");
6801     }
6802     else if (stdout_flag == 1)
6803     {
6804       // do nothing
6805     }
6806     else if (keyspace == 1)
6807     {
6808       // do nothing
6809     }
6810     else
6811     {
6812       log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6813       log_info ("");
6814     }
6815   }
6816
6817   /**
6818    * sanity check
6819    */
6820
6821   if (attack_mode > 7)
6822   {
6823     log_error ("ERROR: Invalid attack-mode specified");
6824
6825     return -1;
6826   }
6827
6828   if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6829   {
6830     log_error ("ERROR: Invalid runtime specified");
6831
6832     return -1;
6833   }
6834
6835   if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6836   {
6837     log_error ("ERROR: Invalid hash-type specified");
6838
6839     return -1;
6840   }
6841
6842   // renamed hash modes
6843
6844   if (hash_mode_chgd)
6845   {
6846     int n = -1;
6847
6848     switch (hash_mode)
6849     {
6850       case 123: n = 124;
6851                 break;
6852     }
6853
6854     if (n >= 0)
6855     {
6856       log_error ("Old -m specified, use -m %d instead", n);
6857
6858       return -1;
6859     }
6860   }
6861
6862   if (username == 1)
6863   {
6864     if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6865     {
6866       log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6867
6868       return -1;
6869     }
6870   }
6871
6872   if (outfile_format > 16)
6873   {
6874     log_error ("ERROR: Invalid outfile-format specified");
6875
6876     return -1;
6877   }
6878
6879   if (left == 1)
6880   {
6881     if (outfile_format_chgd == 1)
6882     {
6883       if (outfile_format > 1)
6884       {
6885         log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6886
6887         return -1;
6888       }
6889     }
6890     else
6891     {
6892       outfile_format = OUTFILE_FMT_HASH;
6893     }
6894   }
6895
6896   if (show == 1)
6897   {
6898     if (outfile_format_chgd == 1)
6899     {
6900       if ((outfile_format > 7) && (outfile_format < 16))
6901       {
6902         log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6903
6904         return -1;
6905       }
6906     }
6907   }
6908
6909   if (increment_min < INCREMENT_MIN)
6910   {
6911     log_error ("ERROR: Invalid increment-min specified");
6912
6913     return -1;
6914   }
6915
6916   if (increment_max > INCREMENT_MAX)
6917   {
6918     log_error ("ERROR: Invalid increment-max specified");
6919
6920     return -1;
6921   }
6922
6923   if (increment_min > increment_max)
6924   {
6925     log_error ("ERROR: Invalid increment-min specified");
6926
6927     return -1;
6928   }
6929
6930   if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6931   {
6932     log_error ("ERROR: Increment is not allowed in attack-mode 0");
6933
6934     return -1;
6935   }
6936
6937   if ((increment == 0) && (increment_min_chgd == 1))
6938   {
6939     log_error ("ERROR: Increment-min is only supported combined with increment switch");
6940
6941     return -1;
6942   }
6943
6944   if ((increment == 0) && (increment_max_chgd == 1))
6945   {
6946     log_error ("ERROR: Increment-max is only supported combined with increment switch");
6947
6948     return -1;
6949   }
6950
6951   if (rp_files_cnt && rp_gen)
6952   {
6953     log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6954
6955     return -1;
6956   }
6957
6958   if (rp_files_cnt || rp_gen)
6959   {
6960     if (attack_mode != ATTACK_MODE_STRAIGHT)
6961     {
6962       log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6963
6964       return -1;
6965     }
6966   }
6967
6968   if (rp_gen_func_min > rp_gen_func_max)
6969   {
6970     log_error ("ERROR: Invalid rp-gen-func-min specified");
6971
6972     return -1;
6973   }
6974
6975   if (kernel_accel_chgd == 1)
6976   {
6977     if (force == 0)
6978     {
6979       log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6980       log_info ("Please consider using the -w option instead");
6981       log_info ("You can use --force to override this but do not post error reports if you do so");
6982       log_info ("");
6983
6984       return -1;
6985     }
6986
6987     if (kernel_accel < 1)
6988     {
6989       log_error ("ERROR: Invalid kernel-accel specified");
6990
6991       return -1;
6992     }
6993
6994     if (kernel_accel > 1024)
6995     {
6996       log_error ("ERROR: Invalid kernel-accel specified");
6997
6998       return -1;
6999     }
7000   }
7001
7002   if (kernel_loops_chgd == 1)
7003   {
7004     if (force == 0)
7005     {
7006       log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
7007       log_info ("Please consider using the -w option instead");
7008       log_info ("You can use --force to override this but do not post error reports if you do so");
7009       log_info ("");
7010
7011       return -1;
7012     }
7013
7014     if (kernel_loops < 1)
7015     {
7016       log_error ("ERROR: Invalid kernel-loops specified");
7017
7018       return -1;
7019     }
7020
7021     if (kernel_loops > 1024)
7022     {
7023       log_error ("ERROR: Invalid kernel-loops specified");
7024
7025       return -1;
7026     }
7027   }
7028
7029   if ((workload_profile < 1) || (workload_profile > 4))
7030   {
7031     log_error ("ERROR: workload-profile %i not available", workload_profile);
7032
7033     return -1;
7034   }
7035
7036   if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
7037   {
7038     log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
7039
7040     return -1;
7041   }
7042
7043   if (show == 1 || left == 1)
7044   {
7045     attack_mode = ATTACK_MODE_NONE;
7046
7047     if (remove == 1)
7048     {
7049       log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
7050
7051       return -1;
7052     }
7053
7054     if (potfile_disable == 1)
7055     {
7056       log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
7057
7058       return -1;
7059     }
7060   }
7061
7062   uint attack_kern = ATTACK_KERN_NONE;
7063
7064   switch (attack_mode)
7065   {
7066     case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
7067     case ATTACK_MODE_COMBI:    attack_kern = ATTACK_KERN_COMBI;    break;
7068     case ATTACK_MODE_BF:       attack_kern = ATTACK_KERN_BF;       break;
7069     case ATTACK_MODE_HYBRID1:  attack_kern = ATTACK_KERN_COMBI;    break;
7070     case ATTACK_MODE_HYBRID2:  attack_kern = ATTACK_KERN_COMBI;    break;
7071   }
7072
7073   if (benchmark == 1)
7074   {
7075     if (myargv[optind] != 0)
7076     {
7077       log_error ("ERROR: Invalid argument for benchmark mode specified");
7078
7079       return -1;
7080     }
7081
7082     if (attack_mode_chgd == 1)
7083     {
7084       if (attack_mode != ATTACK_MODE_BF)
7085       {
7086         log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
7087
7088         return -1;
7089       }
7090     }
7091   }
7092   else
7093   {
7094     if (stdout_flag == 1) // no hash here
7095     {
7096       optind--;
7097     }
7098
7099     if (keyspace == 1)
7100     {
7101       int num_additional_params = 1;
7102
7103       if (attack_kern == ATTACK_KERN_COMBI)
7104       {
7105         num_additional_params = 2;
7106       }
7107
7108       int keyspace_wordlist_specified = myargc - optind - num_additional_params;
7109
7110       if (keyspace_wordlist_specified == 0) optind--;
7111     }
7112
7113     if (attack_kern == ATTACK_KERN_NONE)
7114     {
7115       if ((optind + 1) != myargc)
7116       {
7117         usage_mini_print (myargv[0]);
7118
7119         return -1;
7120       }
7121     }
7122     else if (attack_kern == ATTACK_KERN_STRAIGHT)
7123     {
7124       if ((optind + 1) > myargc)
7125       {
7126         usage_mini_print (myargv[0]);
7127
7128         return -1;
7129       }
7130     }
7131     else if (attack_kern == ATTACK_KERN_COMBI)
7132     {
7133       if ((optind + 3) != myargc)
7134       {
7135         usage_mini_print (myargv[0]);
7136
7137         return -1;
7138       }
7139     }
7140     else if (attack_kern == ATTACK_KERN_BF)
7141     {
7142       if ((optind + 1) > myargc)
7143       {
7144         usage_mini_print (myargv[0]);
7145
7146         return -1;
7147       }
7148     }
7149     else
7150     {
7151       usage_mini_print (myargv[0]);
7152
7153       return -1;
7154     }
7155   }
7156
7157   if (skip != 0 && limit != 0)
7158   {
7159     limit += skip;
7160   }
7161
7162   if (keyspace == 1)
7163   {
7164     if (show == 1)
7165     {
7166       log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
7167
7168       return -1;
7169     }
7170     else if (left == 1)
7171     {
7172       log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
7173
7174       return -1;
7175     }
7176
7177     potfile_disable = 1;
7178
7179     restore_disable = 1;
7180
7181     restore = 0;
7182
7183     weak_hash_threshold = 0;
7184
7185     quiet = 1;
7186   }
7187
7188   if (stdout_flag == 1)
7189   {
7190     status_timer          = 0;
7191     restore_timer         = 0;
7192     restore_disable       = 1;
7193     restore               = 0;
7194     potfile_disable       = 1;
7195     weak_hash_threshold   = 0;
7196     gpu_temp_disable      = 1;
7197     hash_mode             = 2000;
7198     quiet                 = 1;
7199     outfile_format        = OUTFILE_FMT_PLAIN;
7200     kernel_accel          = 1024;
7201     kernel_loops          = 1024;
7202     force                 = 1;
7203     outfile_check_timer   = 0;
7204     session               = "stdout";
7205     opencl_vector_width   = 1;
7206   }
7207
7208   if (remove_timer_chgd == 1)
7209   {
7210     if (remove == 0)
7211     {
7212       log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
7213
7214       return -1;
7215     }
7216
7217     if (remove_timer < 1)
7218     {
7219       log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
7220
7221       return -1;
7222     }
7223   }
7224
7225   if (loopback == 1)
7226   {
7227     if (attack_mode == ATTACK_MODE_STRAIGHT)
7228     {
7229       if ((rp_files_cnt == 0) && (rp_gen == 0))
7230       {
7231         log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
7232
7233         return -1;
7234       }
7235     }
7236     else
7237     {
7238       log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
7239
7240       return -1;
7241     }
7242   }
7243
7244   if (debug_mode > 0)
7245   {
7246     if (attack_mode != ATTACK_MODE_STRAIGHT)
7247     {
7248       log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
7249
7250       return -1;
7251     }
7252
7253     if ((rp_files_cnt == 0) && (rp_gen == 0))
7254     {
7255       log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
7256
7257       return -1;
7258     }
7259   }
7260
7261   if (debug_mode > 4)
7262   {
7263     log_error ("ERROR: Invalid debug-mode specified");
7264
7265     return -1;
7266   }
7267
7268   if (debug_file != NULL)
7269   {
7270     if (debug_mode < 1)
7271     {
7272       log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
7273
7274       return -1;
7275     }
7276   }
7277
7278   if (induction_dir != NULL)
7279   {
7280     if (attack_mode == ATTACK_MODE_BF)
7281     {
7282       log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
7283
7284       return -1;
7285     }
7286   }
7287
7288   if (attack_mode != ATTACK_MODE_STRAIGHT)
7289   {
7290     if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
7291     {
7292       log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
7293
7294       return -1;
7295     }
7296
7297     weak_hash_threshold = 0;
7298   }
7299
7300   if (nvidia_spin_damp > 100)
7301   {
7302     log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
7303
7304     return -1;
7305   }
7306
7307
7308   /**
7309    * induction directory
7310    */
7311
7312   char *induction_directory = NULL;
7313
7314   if (attack_mode != ATTACK_MODE_BF)
7315   {
7316     if (induction_dir == NULL)
7317     {
7318       induction_directory = (char *) mymalloc (session_size);
7319
7320       snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
7321
7322       // create induction folder if it does not already exist
7323
7324       if (keyspace == 0)
7325       {
7326         if (rmdir (induction_directory) == -1)
7327         {
7328           if (errno == ENOENT)
7329           {
7330             // good, we can ignore
7331           }
7332           else if (errno == ENOTEMPTY)
7333           {
7334             char *induction_directory_mv = (char *) mymalloc (session_size);
7335
7336             snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7337
7338             if (rename (induction_directory, induction_directory_mv) != 0)
7339             {
7340               log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7341
7342               return -1;
7343             }
7344           }
7345           else
7346           {
7347             log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7348
7349             return -1;
7350           }
7351         }
7352
7353         if (mkdir (induction_directory, 0700) == -1)
7354         {
7355           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7356
7357           return -1;
7358         }
7359       }
7360     }
7361     else
7362     {
7363       induction_directory = induction_dir;
7364     }
7365   }
7366
7367   data.induction_directory = induction_directory;
7368
7369   /**
7370    * loopback
7371    */
7372
7373   size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7374
7375   char *loopback_file = (char *) mymalloc (loopback_size);
7376
7377   /**
7378    * tuning db
7379    */
7380
7381   char tuning_db_file[256] = { 0 };
7382
7383   snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7384
7385   tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7386
7387   /**
7388    * outfile-check directory
7389    */
7390
7391   char *outfile_check_directory = NULL;
7392
7393   if (outfile_check_dir == NULL)
7394   {
7395     outfile_check_directory = (char *) mymalloc (session_size);
7396
7397     snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7398   }
7399   else
7400   {
7401     outfile_check_directory = outfile_check_dir;
7402   }
7403
7404   data.outfile_check_directory = outfile_check_directory;
7405
7406   if (keyspace == 0)
7407   {
7408     struct stat outfile_check_stat;
7409
7410     if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7411     {
7412       uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7413
7414       if (is_dir == 0)
7415       {
7416         log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7417
7418         return -1;
7419       }
7420     }
7421     else if (outfile_check_dir == NULL)
7422     {
7423       if (mkdir (outfile_check_directory, 0700) == -1)
7424       {
7425         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7426
7427         return -1;
7428       }
7429     }
7430   }
7431
7432   /**
7433    * special other stuff
7434    */
7435
7436   if (hash_mode == 9710)
7437   {
7438     outfile_format      = 5;
7439     outfile_format_chgd = 1;
7440   }
7441
7442   if (hash_mode == 9810)
7443   {
7444     outfile_format      = 5;
7445     outfile_format_chgd = 1;
7446   }
7447
7448   if (hash_mode == 10410)
7449   {
7450     outfile_format      = 5;
7451     outfile_format_chgd = 1;
7452   }
7453
7454   /**
7455    * store stuff
7456    */
7457
7458   data.hash_mode               = hash_mode;
7459   data.restore                 = restore;
7460   data.restore_timer           = restore_timer;
7461   data.restore_disable         = restore_disable;
7462   data.status                  = status;
7463   data.status_timer            = status_timer;
7464   data.machine_readable        = machine_readable;
7465   data.loopback                = loopback;
7466   data.runtime                 = runtime;
7467   data.remove                  = remove;
7468   data.remove_timer            = remove_timer;
7469   data.debug_mode              = debug_mode;
7470   data.debug_file              = debug_file;
7471   data.username                = username;
7472   data.quiet                   = quiet;
7473   data.outfile                 = outfile;
7474   data.outfile_format          = outfile_format;
7475   data.outfile_autohex         = outfile_autohex;
7476   data.hex_charset             = hex_charset;
7477   data.hex_salt                = hex_salt;
7478   data.hex_wordlist            = hex_wordlist;
7479   data.separator               = separator;
7480   data.rp_files                = rp_files;
7481   data.rp_files_cnt            = rp_files_cnt;
7482   data.rp_gen                  = rp_gen;
7483   data.rp_gen_seed             = rp_gen_seed;
7484   data.force                   = force;
7485   data.benchmark               = benchmark;
7486   data.skip                    = skip;
7487   data.limit                   = limit;
7488   #ifdef HAVE_HWMON
7489   data.powertune_enable        = powertune_enable;
7490   #endif
7491   data.logfile_disable         = logfile_disable;
7492   data.truecrypt_keyfiles      = truecrypt_keyfiles;
7493   data.veracrypt_keyfiles      = veracrypt_keyfiles;
7494   data.veracrypt_pim           = veracrypt_pim;
7495   data.scrypt_tmto             = scrypt_tmto;
7496   data.workload_profile        = workload_profile;
7497
7498   /**
7499    * cpu affinity
7500    */
7501
7502   if (cpu_affinity)
7503   {
7504     set_cpu_affinity (cpu_affinity);
7505   }
7506
7507   if (rp_gen_seed_chgd == 0)
7508   {
7509     srand (proc_start);
7510   }
7511   else
7512   {
7513     srand (rp_gen_seed);
7514   }
7515
7516   /**
7517    * logfile init
7518    */
7519
7520   if (logfile_disable == 0)
7521   {
7522     size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7523
7524     char *logfile = (char *) mymalloc (logfile_size);
7525
7526     snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7527
7528     data.logfile = logfile;
7529
7530     char *topid = logfile_generate_topid ();
7531
7532     data.topid = topid;
7533   }
7534
7535   // logfile_append() checks for logfile_disable internally to make it easier from here
7536
7537   #define logfile_top_msg(msg)            logfile_append ("%s\t%s",           data.topid,             (msg));
7538   #define logfile_sub_msg(msg)            logfile_append ("%s\t%s\t%s",       data.topid, data.subid, (msg));
7539   #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu",     data.topid,             (var), (val));
7540   #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7541   #define logfile_top_var_uint(var,val)   logfile_append ("%s\t%s\t%u",       data.topid,             (var), (val));
7542   #define logfile_sub_var_uint(var,val)   logfile_append ("%s\t%s\t%s\t%u",   data.topid, data.subid, (var), (val));
7543   #define logfile_top_var_char(var,val)   logfile_append ("%s\t%s\t%c",       data.topid,             (var), (val));
7544   #define logfile_sub_var_char(var,val)   logfile_append ("%s\t%s\t%s\t%c",   data.topid, data.subid, (var), (val));
7545   #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s",       data.topid,             (var), (val));
7546   #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));
7547
7548   #define logfile_top_uint64(var)         logfile_top_var_uint64 (#var, (var));
7549   #define logfile_sub_uint64(var)         logfile_sub_var_uint64 (#var, (var));
7550   #define logfile_top_uint(var)           logfile_top_var_uint   (#var, (var));
7551   #define logfile_sub_uint(var)           logfile_sub_var_uint   (#var, (var));
7552   #define logfile_top_char(var)           logfile_top_var_char   (#var, (var));
7553   #define logfile_sub_char(var)           logfile_sub_var_char   (#var, (var));
7554   #define logfile_top_string(var)         logfile_top_var_string (#var, (var));
7555   #define logfile_sub_string(var)         logfile_sub_var_string (#var, (var));
7556
7557   logfile_top_msg ("START");
7558
7559   logfile_top_uint   (attack_mode);
7560   logfile_top_uint   (attack_kern);
7561   logfile_top_uint   (benchmark);
7562   logfile_top_uint   (stdout_flag);
7563   logfile_top_uint   (bitmap_min);
7564   logfile_top_uint   (bitmap_max);
7565   logfile_top_uint   (debug_mode);
7566   logfile_top_uint   (force);
7567   logfile_top_uint   (kernel_accel);
7568   logfile_top_uint   (kernel_loops);
7569   logfile_top_uint   (nvidia_spin_damp);
7570   logfile_top_uint   (gpu_temp_disable);
7571   #ifdef HAVE_HWMON
7572   logfile_top_uint   (gpu_temp_abort);
7573   logfile_top_uint   (gpu_temp_retain);
7574   #endif
7575   logfile_top_uint   (hash_mode);
7576   logfile_top_uint   (hex_charset);
7577   logfile_top_uint   (hex_salt);
7578   logfile_top_uint   (hex_wordlist);
7579   logfile_top_uint   (increment);
7580   logfile_top_uint   (increment_max);
7581   logfile_top_uint   (increment_min);
7582   logfile_top_uint   (keyspace);
7583   logfile_top_uint   (left);
7584   logfile_top_uint   (logfile_disable);
7585   logfile_top_uint   (loopback);
7586   logfile_top_uint   (markov_classic);
7587   logfile_top_uint   (markov_disable);
7588   logfile_top_uint   (markov_threshold);
7589   logfile_top_uint   (outfile_autohex);
7590   logfile_top_uint   (outfile_check_timer);
7591   logfile_top_uint   (outfile_format);
7592   logfile_top_uint   (potfile_disable);
7593   logfile_top_string (potfile_path);
7594   #if defined(HAVE_HWMON)
7595   logfile_top_uint   (powertune_enable);
7596   #endif
7597   logfile_top_uint   (scrypt_tmto);
7598   logfile_top_uint   (quiet);
7599   logfile_top_uint   (remove);
7600   logfile_top_uint   (remove_timer);
7601   logfile_top_uint   (restore);
7602   logfile_top_uint   (restore_disable);
7603   logfile_top_uint   (restore_timer);
7604   logfile_top_uint   (rp_gen);
7605   logfile_top_uint   (rp_gen_func_max);
7606   logfile_top_uint   (rp_gen_func_min);
7607   logfile_top_uint   (rp_gen_seed);
7608   logfile_top_uint   (runtime);
7609   logfile_top_uint   (segment_size);
7610   logfile_top_uint   (show);
7611   logfile_top_uint   (status);
7612   logfile_top_uint   (machine_readable);
7613   logfile_top_uint   (status_timer);
7614   logfile_top_uint   (usage);
7615   logfile_top_uint   (username);
7616   logfile_top_uint   (version);
7617   logfile_top_uint   (weak_hash_threshold);
7618   logfile_top_uint   (workload_profile);
7619   logfile_top_uint64 (limit);
7620   logfile_top_uint64 (skip);
7621   logfile_top_char   (separator);
7622   logfile_top_string (cpu_affinity);
7623   logfile_top_string (custom_charset_1);
7624   logfile_top_string (custom_charset_2);
7625   logfile_top_string (custom_charset_3);
7626   logfile_top_string (custom_charset_4);
7627   logfile_top_string (debug_file);
7628   logfile_top_string (opencl_devices);
7629   logfile_top_string (opencl_platforms);
7630   logfile_top_string (opencl_device_types);
7631   logfile_top_uint   (opencl_vector_width);
7632   logfile_top_string (induction_dir);
7633   logfile_top_string (markov_hcstat);
7634   logfile_top_string (outfile);
7635   logfile_top_string (outfile_check_dir);
7636   logfile_top_string (rule_buf_l);
7637   logfile_top_string (rule_buf_r);
7638   logfile_top_string (session);
7639   logfile_top_string (truecrypt_keyfiles);
7640   logfile_top_string (veracrypt_keyfiles);
7641   logfile_top_uint   (veracrypt_pim);
7642
7643   /**
7644    * Init OpenCL library loader
7645    */
7646
7647   if (keyspace == 0)
7648   {
7649     ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7650
7651     ocl_init (ocl);
7652
7653     data.ocl = ocl;
7654   }
7655
7656   /**
7657    * OpenCL platform selection
7658    */
7659
7660   u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7661
7662   /**
7663    * OpenCL device selection
7664    */
7665
7666   u32 devices_filter = setup_devices_filter (opencl_devices);
7667
7668   /**
7669    * OpenCL device type selection
7670    */
7671
7672   cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7673
7674   /**
7675    * benchmark
7676    */
7677
7678   if (benchmark == 1)
7679   {
7680     /**
7681      * disable useless stuff for benchmark
7682      */
7683
7684     status_timer          = 0;
7685     restore_timer         = 0;
7686     restore_disable       = 1;
7687     potfile_disable       = 1;
7688     weak_hash_threshold   = 0;
7689     nvidia_spin_damp      = 0;
7690     gpu_temp_disable      = 1;
7691     outfile_check_timer   = 0;
7692
7693     #ifdef HAVE_HWMON
7694     if (powertune_enable == 1)
7695     {
7696       gpu_temp_disable = 0;
7697     }
7698     #endif
7699
7700     data.status_timer         = status_timer;
7701     data.restore_timer        = restore_timer;
7702     data.restore_disable      = restore_disable;
7703     data.outfile_check_timer  = outfile_check_timer;
7704
7705     /**
7706      * force attack mode to be bruteforce
7707      */
7708
7709     attack_mode = ATTACK_MODE_BF;
7710     attack_kern = ATTACK_KERN_BF;
7711
7712     if (workload_profile_chgd == 0)
7713     {
7714       workload_profile = 3;
7715
7716       data.workload_profile = workload_profile;
7717     }
7718   }
7719
7720   /**
7721    * status, monitor and outfile remove threads
7722    */
7723
7724   uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7725
7726   data.wordlist_mode = wordlist_mode;
7727
7728   if (wordlist_mode == WL_MODE_STDIN)
7729   {
7730     status = 1;
7731
7732     data.status = status;
7733   }
7734
7735   uint outer_threads_cnt = 0;
7736
7737   hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7738
7739   data.shutdown_outer = 0;
7740
7741   if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7742   {
7743     if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7744     {
7745       hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7746
7747       outer_threads_cnt++;
7748     }
7749   }
7750
7751   /**
7752    * config
7753    */
7754
7755   uint hash_type   = 0;
7756   uint salt_type   = 0;
7757   uint attack_exec = 0;
7758   uint opts_type   = 0;
7759   uint kern_type   = 0;
7760   uint dgst_size   = 0;
7761   uint esalt_size  = 0;
7762   uint opti_type   = 0;
7763   uint dgst_pos0   = -1;
7764   uint dgst_pos1   = -1;
7765   uint dgst_pos2   = -1;
7766   uint dgst_pos3   = -1;
7767
7768   int (*parse_func) (char *, uint, hash_t *);
7769   int (*sort_by_digest) (const void *, const void *);
7770
7771   uint algorithm_pos = 0;
7772   uint algorithm_max = 1;
7773
7774   uint *algorithms = default_benchmark_algorithms;
7775
7776   if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7777
7778   for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7779   {
7780     /*
7781      * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7782      * the following algos are skipped entirely
7783      */
7784
7785     if (algorithm_pos > 0)
7786     {
7787       local_free (rd);
7788
7789       rd = init_restore (argc, argv);
7790
7791       data.rd = rd;
7792     }
7793
7794     /**
7795      * update hash_mode in case of multihash benchmark
7796      */
7797
7798     if (benchmark == 1)
7799     {
7800       if (hash_mode_chgd == 0)
7801       {
7802         hash_mode = algorithms[algorithm_pos];
7803
7804         data.hash_mode = hash_mode;
7805       }
7806
7807       quiet = 1;
7808
7809       data.quiet = quiet;
7810     }
7811
7812     switch (hash_mode)
7813     {
7814       case     0:  hash_type   = HASH_TYPE_MD5;
7815                    salt_type   = SALT_TYPE_NONE;
7816                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7818                                | OPTS_TYPE_PT_ADD80
7819                                | OPTS_TYPE_PT_ADDBITS14;
7820                    kern_type   = KERN_TYPE_MD5;
7821                    dgst_size   = DGST_SIZE_4_4;
7822                    parse_func  = md5_parse_hash;
7823                    sort_by_digest = sort_by_digest_4_4;
7824                    opti_type   = OPTI_TYPE_ZERO_BYTE
7825                                | OPTI_TYPE_PRECOMPUTE_INIT
7826                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7827                                | OPTI_TYPE_MEET_IN_MIDDLE
7828                                | OPTI_TYPE_EARLY_SKIP
7829                                | OPTI_TYPE_NOT_ITERATED
7830                                | OPTI_TYPE_NOT_SALTED
7831                                | OPTI_TYPE_RAW_HASH;
7832                    dgst_pos0   = 0;
7833                    dgst_pos1   = 3;
7834                    dgst_pos2   = 2;
7835                    dgst_pos3   = 1;
7836                    break;
7837
7838       case    10:  hash_type   = HASH_TYPE_MD5;
7839                    salt_type   = SALT_TYPE_INTERN;
7840                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7842                                | OPTS_TYPE_ST_ADD80
7843                                | OPTS_TYPE_ST_ADDBITS14;
7844                    kern_type   = KERN_TYPE_MD5_PWSLT;
7845                    dgst_size   = DGST_SIZE_4_4;
7846                    parse_func  = md5s_parse_hash;
7847                    sort_by_digest = sort_by_digest_4_4;
7848                    opti_type   = OPTI_TYPE_ZERO_BYTE
7849                                | OPTI_TYPE_PRECOMPUTE_INIT
7850                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7851                                | OPTI_TYPE_MEET_IN_MIDDLE
7852                                | OPTI_TYPE_EARLY_SKIP
7853                                | OPTI_TYPE_NOT_ITERATED
7854                                | OPTI_TYPE_APPENDED_SALT
7855                                | OPTI_TYPE_RAW_HASH;
7856                    dgst_pos0   = 0;
7857                    dgst_pos1   = 3;
7858                    dgst_pos2   = 2;
7859                    dgst_pos3   = 1;
7860                    break;
7861
7862       case    11:  hash_type   = HASH_TYPE_MD5;
7863                    salt_type   = SALT_TYPE_INTERN;
7864                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7866                                | OPTS_TYPE_ST_ADD80
7867                                | OPTS_TYPE_ST_ADDBITS14;
7868                    kern_type   = KERN_TYPE_MD5_PWSLT;
7869                    dgst_size   = DGST_SIZE_4_4;
7870                    parse_func  = joomla_parse_hash;
7871                    sort_by_digest = sort_by_digest_4_4;
7872                    opti_type   = OPTI_TYPE_ZERO_BYTE
7873                                | OPTI_TYPE_PRECOMPUTE_INIT
7874                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7875                                | OPTI_TYPE_MEET_IN_MIDDLE
7876                                | OPTI_TYPE_EARLY_SKIP
7877                                | OPTI_TYPE_NOT_ITERATED
7878                                | OPTI_TYPE_APPENDED_SALT
7879                                | OPTI_TYPE_RAW_HASH;
7880                    dgst_pos0   = 0;
7881                    dgst_pos1   = 3;
7882                    dgst_pos2   = 2;
7883                    dgst_pos3   = 1;
7884                    break;
7885
7886       case    12:  hash_type   = HASH_TYPE_MD5;
7887                    salt_type   = SALT_TYPE_INTERN;
7888                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7890                                | OPTS_TYPE_ST_ADD80
7891                                | OPTS_TYPE_ST_ADDBITS14;
7892                    kern_type   = KERN_TYPE_MD5_PWSLT;
7893                    dgst_size   = DGST_SIZE_4_4;
7894                    parse_func  = postgresql_parse_hash;
7895                    sort_by_digest = sort_by_digest_4_4;
7896                    opti_type   = OPTI_TYPE_ZERO_BYTE
7897                                | OPTI_TYPE_PRECOMPUTE_INIT
7898                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7899                                | OPTI_TYPE_MEET_IN_MIDDLE
7900                                | OPTI_TYPE_EARLY_SKIP
7901                                | OPTI_TYPE_NOT_ITERATED
7902                                | OPTI_TYPE_APPENDED_SALT
7903                                | OPTI_TYPE_RAW_HASH;
7904                    dgst_pos0   = 0;
7905                    dgst_pos1   = 3;
7906                    dgst_pos2   = 2;
7907                    dgst_pos3   = 1;
7908                    break;
7909
7910       case    20:  hash_type   = HASH_TYPE_MD5;
7911                    salt_type   = SALT_TYPE_INTERN;
7912                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7914                                | OPTS_TYPE_PT_ADD80
7915                                | OPTS_TYPE_PT_ADDBITS14;
7916                    kern_type   = KERN_TYPE_MD5_SLTPW;
7917                    dgst_size   = DGST_SIZE_4_4;
7918                    parse_func  = md5s_parse_hash;
7919                    sort_by_digest = sort_by_digest_4_4;
7920                    opti_type   = OPTI_TYPE_ZERO_BYTE
7921                                | OPTI_TYPE_PRECOMPUTE_INIT
7922                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7923                                | OPTI_TYPE_EARLY_SKIP
7924                                | OPTI_TYPE_NOT_ITERATED
7925                                | OPTI_TYPE_PREPENDED_SALT
7926                                | OPTI_TYPE_RAW_HASH;
7927                    dgst_pos0   = 0;
7928                    dgst_pos1   = 3;
7929                    dgst_pos2   = 2;
7930                    dgst_pos3   = 1;
7931                    break;
7932
7933       case    21:  hash_type   = HASH_TYPE_MD5;
7934                    salt_type   = SALT_TYPE_INTERN;
7935                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7937                                | OPTS_TYPE_PT_ADD80
7938                                | OPTS_TYPE_PT_ADDBITS14;
7939                    kern_type   = KERN_TYPE_MD5_SLTPW;
7940                    dgst_size   = DGST_SIZE_4_4;
7941                    parse_func  = osc_parse_hash;
7942                    sort_by_digest = sort_by_digest_4_4;
7943                    opti_type   = OPTI_TYPE_ZERO_BYTE
7944                                | OPTI_TYPE_PRECOMPUTE_INIT
7945                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7946                                | OPTI_TYPE_EARLY_SKIP
7947                                | OPTI_TYPE_NOT_ITERATED
7948                                | OPTI_TYPE_PREPENDED_SALT
7949                                | OPTI_TYPE_RAW_HASH;
7950                    dgst_pos0   = 0;
7951                    dgst_pos1   = 3;
7952                    dgst_pos2   = 2;
7953                    dgst_pos3   = 1;
7954                    break;
7955
7956       case    22:  hash_type   = HASH_TYPE_MD5;
7957                    salt_type   = SALT_TYPE_EMBEDDED;
7958                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7960                                | OPTS_TYPE_PT_ADD80
7961                                | OPTS_TYPE_PT_ADDBITS14;
7962                    kern_type   = KERN_TYPE_MD5_SLTPW;
7963                    dgst_size   = DGST_SIZE_4_4;
7964                    parse_func  = netscreen_parse_hash;
7965                    sort_by_digest = sort_by_digest_4_4;
7966                    opti_type   = OPTI_TYPE_ZERO_BYTE
7967                                | OPTI_TYPE_PRECOMPUTE_INIT
7968                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7969                                | OPTI_TYPE_EARLY_SKIP
7970                                | OPTI_TYPE_NOT_ITERATED
7971                                | OPTI_TYPE_PREPENDED_SALT
7972                                | OPTI_TYPE_RAW_HASH;
7973                    dgst_pos0   = 0;
7974                    dgst_pos1   = 3;
7975                    dgst_pos2   = 2;
7976                    dgst_pos3   = 1;
7977                    break;
7978
7979       case    23:  hash_type   = HASH_TYPE_MD5;
7980                    salt_type   = SALT_TYPE_EMBEDDED;
7981                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
7983                                | OPTS_TYPE_PT_ADD80
7984                                | OPTS_TYPE_PT_ADDBITS14;
7985                    kern_type   = KERN_TYPE_MD5_SLTPW;
7986                    dgst_size   = DGST_SIZE_4_4;
7987                    parse_func  = skype_parse_hash;
7988                    sort_by_digest = sort_by_digest_4_4;
7989                    opti_type   = OPTI_TYPE_ZERO_BYTE
7990                                | OPTI_TYPE_PRECOMPUTE_INIT
7991                                | OPTI_TYPE_PRECOMPUTE_MERKLE
7992                                | OPTI_TYPE_EARLY_SKIP
7993                                | OPTI_TYPE_NOT_ITERATED
7994                                | OPTI_TYPE_PREPENDED_SALT
7995                                | OPTI_TYPE_RAW_HASH;
7996                    dgst_pos0   = 0;
7997                    dgst_pos1   = 3;
7998                    dgst_pos2   = 2;
7999                    dgst_pos3   = 1;
8000                    break;
8001
8002       case    30:  hash_type   = HASH_TYPE_MD5;
8003                    salt_type   = SALT_TYPE_INTERN;
8004                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8006                                | OPTS_TYPE_PT_UNICODE
8007                                | OPTS_TYPE_ST_ADD80
8008                                | OPTS_TYPE_ST_ADDBITS14;
8009                    kern_type   = KERN_TYPE_MD5_PWUSLT;
8010                    dgst_size   = DGST_SIZE_4_4;
8011                    parse_func  = md5s_parse_hash;
8012                    sort_by_digest = sort_by_digest_4_4;
8013                    opti_type   = OPTI_TYPE_ZERO_BYTE
8014                                | OPTI_TYPE_PRECOMPUTE_INIT
8015                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8016                                | OPTI_TYPE_MEET_IN_MIDDLE
8017                                | OPTI_TYPE_EARLY_SKIP
8018                                | OPTI_TYPE_NOT_ITERATED
8019                                | OPTI_TYPE_APPENDED_SALT
8020                                | OPTI_TYPE_RAW_HASH;
8021                    dgst_pos0   = 0;
8022                    dgst_pos1   = 3;
8023                    dgst_pos2   = 2;
8024                    dgst_pos3   = 1;
8025                    break;
8026
8027       case    40:  hash_type   = HASH_TYPE_MD5;
8028                    salt_type   = SALT_TYPE_INTERN;
8029                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8031                                | OPTS_TYPE_PT_ADD80
8032                                | OPTS_TYPE_PT_ADDBITS14
8033                                | OPTS_TYPE_PT_UNICODE;
8034                    kern_type   = KERN_TYPE_MD5_SLTPWU;
8035                    dgst_size   = DGST_SIZE_4_4;
8036                    parse_func  = md5s_parse_hash;
8037                    sort_by_digest = sort_by_digest_4_4;
8038                    opti_type   = OPTI_TYPE_ZERO_BYTE
8039                                | OPTI_TYPE_PRECOMPUTE_INIT
8040                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8041                                | OPTI_TYPE_EARLY_SKIP
8042                                | OPTI_TYPE_NOT_ITERATED
8043                                | OPTI_TYPE_PREPENDED_SALT
8044                                | OPTI_TYPE_RAW_HASH;
8045                    dgst_pos0   = 0;
8046                    dgst_pos1   = 3;
8047                    dgst_pos2   = 2;
8048                    dgst_pos3   = 1;
8049                    break;
8050
8051       case    50:  hash_type   = HASH_TYPE_MD5;
8052                    salt_type   = SALT_TYPE_INTERN;
8053                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8054                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8055                                | OPTS_TYPE_ST_ADD80
8056                                | OPTS_TYPE_ST_ADDBITS14;
8057                    kern_type   = KERN_TYPE_HMACMD5_PW;
8058                    dgst_size   = DGST_SIZE_4_4;
8059                    parse_func  = hmacmd5_parse_hash;
8060                    sort_by_digest = sort_by_digest_4_4;
8061                    opti_type   = OPTI_TYPE_ZERO_BYTE
8062                                | OPTI_TYPE_NOT_ITERATED;
8063                    dgst_pos0   = 0;
8064                    dgst_pos1   = 3;
8065                    dgst_pos2   = 2;
8066                    dgst_pos3   = 1;
8067                    break;
8068
8069       case    60:  hash_type   = HASH_TYPE_MD5;
8070                    salt_type   = SALT_TYPE_INTERN;
8071                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8073                                | OPTS_TYPE_PT_ADD80
8074                                | OPTS_TYPE_PT_ADDBITS14;
8075                    kern_type   = KERN_TYPE_HMACMD5_SLT;
8076                    dgst_size   = DGST_SIZE_4_4;
8077                    parse_func  = hmacmd5_parse_hash;
8078                    sort_by_digest = sort_by_digest_4_4;
8079                    opti_type   = OPTI_TYPE_ZERO_BYTE
8080                                | OPTI_TYPE_NOT_ITERATED;
8081                    dgst_pos0   = 0;
8082                    dgst_pos1   = 3;
8083                    dgst_pos2   = 2;
8084                    dgst_pos3   = 1;
8085                    break;
8086
8087       case   100:  hash_type   = HASH_TYPE_SHA1;
8088                    salt_type   = SALT_TYPE_NONE;
8089                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8091                                | OPTS_TYPE_PT_ADD80
8092                                | OPTS_TYPE_PT_ADDBITS15;
8093                    kern_type   = KERN_TYPE_SHA1;
8094                    dgst_size   = DGST_SIZE_4_5;
8095                    parse_func  = sha1_parse_hash;
8096                    sort_by_digest = sort_by_digest_4_5;
8097                    opti_type   = OPTI_TYPE_ZERO_BYTE
8098                                | OPTI_TYPE_PRECOMPUTE_INIT
8099                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8100                                | OPTI_TYPE_EARLY_SKIP
8101                                | OPTI_TYPE_NOT_ITERATED
8102                                | OPTI_TYPE_NOT_SALTED
8103                                | OPTI_TYPE_RAW_HASH;
8104                    dgst_pos0   = 3;
8105                    dgst_pos1   = 4;
8106                    dgst_pos2   = 2;
8107                    dgst_pos3   = 1;
8108                    break;
8109
8110       case   101:  hash_type   = HASH_TYPE_SHA1;
8111                    salt_type   = SALT_TYPE_NONE;
8112                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8114                                | OPTS_TYPE_PT_ADD80
8115                                | OPTS_TYPE_PT_ADDBITS15;
8116                    kern_type   = KERN_TYPE_SHA1;
8117                    dgst_size   = DGST_SIZE_4_5;
8118                    parse_func  = sha1b64_parse_hash;
8119                    sort_by_digest = sort_by_digest_4_5;
8120                    opti_type   = OPTI_TYPE_ZERO_BYTE
8121                                | OPTI_TYPE_PRECOMPUTE_INIT
8122                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8123                                | OPTI_TYPE_EARLY_SKIP
8124                                | OPTI_TYPE_NOT_ITERATED
8125                                | OPTI_TYPE_NOT_SALTED
8126                                | OPTI_TYPE_RAW_HASH;
8127                    dgst_pos0   = 3;
8128                    dgst_pos1   = 4;
8129                    dgst_pos2   = 2;
8130                    dgst_pos3   = 1;
8131                    break;
8132
8133       case   110:  hash_type   = HASH_TYPE_SHA1;
8134                    salt_type   = SALT_TYPE_INTERN;
8135                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8137                                | OPTS_TYPE_ST_ADD80
8138                                | OPTS_TYPE_ST_ADDBITS15;
8139                    kern_type   = KERN_TYPE_SHA1_PWSLT;
8140                    dgst_size   = DGST_SIZE_4_5;
8141                    parse_func  = sha1s_parse_hash;
8142                    sort_by_digest = sort_by_digest_4_5;
8143                    opti_type   = OPTI_TYPE_ZERO_BYTE
8144                                | OPTI_TYPE_PRECOMPUTE_INIT
8145                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8146                                | OPTI_TYPE_EARLY_SKIP
8147                                | OPTI_TYPE_NOT_ITERATED
8148                                | OPTI_TYPE_APPENDED_SALT
8149                                | OPTI_TYPE_RAW_HASH;
8150                    dgst_pos0   = 3;
8151                    dgst_pos1   = 4;
8152                    dgst_pos2   = 2;
8153                    dgst_pos3   = 1;
8154                    break;
8155
8156       case   111:  hash_type   = HASH_TYPE_SHA1;
8157                    salt_type   = SALT_TYPE_EMBEDDED;
8158                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8159                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8160                                | OPTS_TYPE_ST_ADD80
8161                                | OPTS_TYPE_ST_ADDBITS15;
8162                    kern_type   = KERN_TYPE_SHA1_PWSLT;
8163                    dgst_size   = DGST_SIZE_4_5;
8164                    parse_func  = sha1b64s_parse_hash;
8165                    sort_by_digest = sort_by_digest_4_5;
8166                    opti_type   = OPTI_TYPE_ZERO_BYTE
8167                                | OPTI_TYPE_PRECOMPUTE_INIT
8168                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8169                                | OPTI_TYPE_EARLY_SKIP
8170                                | OPTI_TYPE_NOT_ITERATED
8171                                | OPTI_TYPE_APPENDED_SALT
8172                                | OPTI_TYPE_RAW_HASH;
8173                    dgst_pos0   = 3;
8174                    dgst_pos1   = 4;
8175                    dgst_pos2   = 2;
8176                    dgst_pos3   = 1;
8177                    break;
8178
8179       case   112:  hash_type   = HASH_TYPE_SHA1;
8180                    salt_type   = SALT_TYPE_INTERN;
8181                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8183                                | OPTS_TYPE_ST_ADD80
8184                                | OPTS_TYPE_ST_ADDBITS15
8185                                | OPTS_TYPE_ST_HEX;
8186                    kern_type   = KERN_TYPE_SHA1_PWSLT;
8187                    dgst_size   = DGST_SIZE_4_5;
8188                    parse_func  = oracles_parse_hash;
8189                    sort_by_digest = sort_by_digest_4_5;
8190                    opti_type   = OPTI_TYPE_ZERO_BYTE
8191                                | OPTI_TYPE_PRECOMPUTE_INIT
8192                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8193                                | OPTI_TYPE_EARLY_SKIP
8194                                | OPTI_TYPE_NOT_ITERATED
8195                                | OPTI_TYPE_APPENDED_SALT
8196                                | OPTI_TYPE_RAW_HASH;
8197                    dgst_pos0   = 3;
8198                    dgst_pos1   = 4;
8199                    dgst_pos2   = 2;
8200                    dgst_pos3   = 1;
8201                    break;
8202
8203       case   120:  hash_type   = HASH_TYPE_SHA1;
8204                    salt_type   = SALT_TYPE_INTERN;
8205                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8207                                | OPTS_TYPE_PT_ADD80
8208                                | OPTS_TYPE_PT_ADDBITS15;
8209                    kern_type   = KERN_TYPE_SHA1_SLTPW;
8210                    dgst_size   = DGST_SIZE_4_5;
8211                    parse_func  = sha1s_parse_hash;
8212                    sort_by_digest = sort_by_digest_4_5;
8213                    opti_type   = OPTI_TYPE_ZERO_BYTE
8214                                | OPTI_TYPE_PRECOMPUTE_INIT
8215                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8216                                | OPTI_TYPE_EARLY_SKIP
8217                                | OPTI_TYPE_NOT_ITERATED
8218                                | OPTI_TYPE_PREPENDED_SALT
8219                                | OPTI_TYPE_RAW_HASH;
8220                    dgst_pos0   = 3;
8221                    dgst_pos1   = 4;
8222                    dgst_pos2   = 2;
8223                    dgst_pos3   = 1;
8224                    break;
8225
8226       case   121:  hash_type   = HASH_TYPE_SHA1;
8227                    salt_type   = SALT_TYPE_INTERN;
8228                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8230                                | OPTS_TYPE_PT_ADD80
8231                                | OPTS_TYPE_PT_ADDBITS15
8232                                | OPTS_TYPE_ST_LOWER;
8233                    kern_type   = KERN_TYPE_SHA1_SLTPW;
8234                    dgst_size   = DGST_SIZE_4_5;
8235                    parse_func  = smf_parse_hash;
8236                    sort_by_digest = sort_by_digest_4_5;
8237                    opti_type   = OPTI_TYPE_ZERO_BYTE
8238                                | OPTI_TYPE_PRECOMPUTE_INIT
8239                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8240                                | OPTI_TYPE_EARLY_SKIP
8241                                | OPTI_TYPE_NOT_ITERATED
8242                                | OPTI_TYPE_PREPENDED_SALT
8243                                | OPTI_TYPE_RAW_HASH;
8244                    dgst_pos0   = 3;
8245                    dgst_pos1   = 4;
8246                    dgst_pos2   = 2;
8247                    dgst_pos3   = 1;
8248                    break;
8249
8250       case   122:  hash_type   = HASH_TYPE_SHA1;
8251                    salt_type   = SALT_TYPE_EMBEDDED;
8252                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8254                                | OPTS_TYPE_PT_ADD80
8255                                | OPTS_TYPE_PT_ADDBITS15
8256                                | OPTS_TYPE_ST_HEX;
8257                    kern_type   = KERN_TYPE_SHA1_SLTPW;
8258                    dgst_size   = DGST_SIZE_4_5;
8259                    parse_func  = osx1_parse_hash;
8260                    sort_by_digest = sort_by_digest_4_5;
8261                    opti_type   = OPTI_TYPE_ZERO_BYTE
8262                                | OPTI_TYPE_PRECOMPUTE_INIT
8263                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8264                                | OPTI_TYPE_EARLY_SKIP
8265                                | OPTI_TYPE_NOT_ITERATED
8266                                | OPTI_TYPE_PREPENDED_SALT
8267                                | OPTI_TYPE_RAW_HASH;
8268                    dgst_pos0   = 3;
8269                    dgst_pos1   = 4;
8270                    dgst_pos2   = 2;
8271                    dgst_pos3   = 1;
8272                    break;
8273
8274       case   124:  hash_type   = HASH_TYPE_SHA1;
8275                    salt_type   = SALT_TYPE_EMBEDDED;
8276                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8278                                | OPTS_TYPE_PT_ADD80
8279                                | OPTS_TYPE_PT_ADDBITS15;
8280                    kern_type   = KERN_TYPE_SHA1_SLTPW;
8281                    dgst_size   = DGST_SIZE_4_5;
8282                    parse_func  = djangosha1_parse_hash;
8283                    sort_by_digest = sort_by_digest_4_5;
8284                    opti_type   = OPTI_TYPE_ZERO_BYTE
8285                                | OPTI_TYPE_PRECOMPUTE_INIT
8286                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8287                                | OPTI_TYPE_EARLY_SKIP
8288                                | OPTI_TYPE_NOT_ITERATED
8289                                | OPTI_TYPE_PREPENDED_SALT
8290                                | OPTI_TYPE_RAW_HASH;
8291                    dgst_pos0   = 3;
8292                    dgst_pos1   = 4;
8293                    dgst_pos2   = 2;
8294                    dgst_pos3   = 1;
8295                    break;
8296
8297       case   125:  hash_type   = HASH_TYPE_SHA1;
8298                    salt_type   = SALT_TYPE_EMBEDDED;
8299                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8301                                | OPTS_TYPE_PT_ADD80
8302                                | OPTS_TYPE_PT_ADDBITS15
8303                                | OPTS_TYPE_ST_HEX;
8304                    kern_type   = KERN_TYPE_SHA1_SLTPW;
8305                    dgst_size   = DGST_SIZE_4_5;
8306                    parse_func  = arubaos_parse_hash;
8307                    sort_by_digest = sort_by_digest_4_5;
8308                    opti_type   = OPTI_TYPE_ZERO_BYTE
8309                                | OPTI_TYPE_PRECOMPUTE_INIT
8310                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8311                                | OPTI_TYPE_EARLY_SKIP
8312                                | OPTI_TYPE_NOT_ITERATED
8313                                | OPTI_TYPE_PREPENDED_SALT
8314                                | OPTI_TYPE_RAW_HASH;
8315                    dgst_pos0   = 3;
8316                    dgst_pos1   = 4;
8317                    dgst_pos2   = 2;
8318                    dgst_pos3   = 1;
8319                    break;
8320
8321       case   130:  hash_type   = HASH_TYPE_SHA1;
8322                    salt_type   = SALT_TYPE_INTERN;
8323                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8325                                | OPTS_TYPE_PT_UNICODE
8326                                | OPTS_TYPE_ST_ADD80
8327                                | OPTS_TYPE_ST_ADDBITS15;
8328                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8329                    dgst_size   = DGST_SIZE_4_5;
8330                    parse_func  = sha1s_parse_hash;
8331                    sort_by_digest = sort_by_digest_4_5;
8332                    opti_type   = OPTI_TYPE_ZERO_BYTE
8333                                | OPTI_TYPE_PRECOMPUTE_INIT
8334                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8335                                | OPTI_TYPE_EARLY_SKIP
8336                                | OPTI_TYPE_NOT_ITERATED
8337                                | OPTI_TYPE_APPENDED_SALT
8338                                | OPTI_TYPE_RAW_HASH;
8339                    dgst_pos0   = 3;
8340                    dgst_pos1   = 4;
8341                    dgst_pos2   = 2;
8342                    dgst_pos3   = 1;
8343                    break;
8344
8345       case   131:  hash_type   = HASH_TYPE_SHA1;
8346                    salt_type   = SALT_TYPE_EMBEDDED;
8347                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8349                                | OPTS_TYPE_PT_UNICODE
8350                                | OPTS_TYPE_PT_UPPER
8351                                | OPTS_TYPE_ST_ADD80
8352                                | OPTS_TYPE_ST_ADDBITS15
8353                                | OPTS_TYPE_ST_HEX;
8354                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8355                    dgst_size   = DGST_SIZE_4_5;
8356                    parse_func  = mssql2000_parse_hash;
8357                    sort_by_digest = sort_by_digest_4_5;
8358                    opti_type   = OPTI_TYPE_ZERO_BYTE
8359                                | OPTI_TYPE_PRECOMPUTE_INIT
8360                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8361                                | OPTI_TYPE_EARLY_SKIP
8362                                | OPTI_TYPE_NOT_ITERATED
8363                                | OPTI_TYPE_APPENDED_SALT
8364                                | OPTI_TYPE_RAW_HASH;
8365                    dgst_pos0   = 3;
8366                    dgst_pos1   = 4;
8367                    dgst_pos2   = 2;
8368                    dgst_pos3   = 1;
8369                    break;
8370
8371       case   132:  hash_type   = HASH_TYPE_SHA1;
8372                    salt_type   = SALT_TYPE_EMBEDDED;
8373                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8375                                | OPTS_TYPE_PT_UNICODE
8376                                | OPTS_TYPE_ST_ADD80
8377                                | OPTS_TYPE_ST_ADDBITS15
8378                                | OPTS_TYPE_ST_HEX;
8379                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8380                    dgst_size   = DGST_SIZE_4_5;
8381                    parse_func  = mssql2005_parse_hash;
8382                    sort_by_digest = sort_by_digest_4_5;
8383                    opti_type   = OPTI_TYPE_ZERO_BYTE
8384                                | OPTI_TYPE_PRECOMPUTE_INIT
8385                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8386                                | OPTI_TYPE_EARLY_SKIP
8387                                | OPTI_TYPE_NOT_ITERATED
8388                                | OPTI_TYPE_APPENDED_SALT
8389                                | OPTI_TYPE_RAW_HASH;
8390                    dgst_pos0   = 3;
8391                    dgst_pos1   = 4;
8392                    dgst_pos2   = 2;
8393                    dgst_pos3   = 1;
8394                    break;
8395
8396       case   133:  hash_type   = HASH_TYPE_SHA1;
8397                    salt_type   = SALT_TYPE_EMBEDDED;
8398                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8400                                | OPTS_TYPE_PT_UNICODE
8401                                | OPTS_TYPE_ST_ADD80
8402                                | OPTS_TYPE_ST_ADDBITS15;
8403                    kern_type   = KERN_TYPE_SHA1_PWUSLT;
8404                    dgst_size   = DGST_SIZE_4_5;
8405                    parse_func  = peoplesoft_parse_hash;
8406                    sort_by_digest = sort_by_digest_4_5;
8407                    opti_type   = OPTI_TYPE_ZERO_BYTE
8408                                | OPTI_TYPE_PRECOMPUTE_INIT
8409                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8410                                | OPTI_TYPE_EARLY_SKIP
8411                                | OPTI_TYPE_NOT_ITERATED
8412                                | OPTI_TYPE_APPENDED_SALT
8413                                | OPTI_TYPE_RAW_HASH;
8414                    dgst_pos0   = 3;
8415                    dgst_pos1   = 4;
8416                    dgst_pos2   = 2;
8417                    dgst_pos3   = 1;
8418                    break;
8419
8420       case   140:  hash_type   = HASH_TYPE_SHA1;
8421                    salt_type   = SALT_TYPE_INTERN;
8422                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8423                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8424                                | OPTS_TYPE_PT_ADD80
8425                                | OPTS_TYPE_PT_ADDBITS15
8426                                | OPTS_TYPE_PT_UNICODE;
8427                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8428                    dgst_size   = DGST_SIZE_4_5;
8429                    parse_func  = sha1s_parse_hash;
8430                    sort_by_digest = sort_by_digest_4_5;
8431                    opti_type   = OPTI_TYPE_ZERO_BYTE
8432                                | OPTI_TYPE_PRECOMPUTE_INIT
8433                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8434                                | OPTI_TYPE_EARLY_SKIP
8435                                | OPTI_TYPE_NOT_ITERATED
8436                                | OPTI_TYPE_PREPENDED_SALT
8437                                | OPTI_TYPE_RAW_HASH;
8438                    dgst_pos0   = 3;
8439                    dgst_pos1   = 4;
8440                    dgst_pos2   = 2;
8441                    dgst_pos3   = 1;
8442                    break;
8443
8444       case   141:  hash_type   = HASH_TYPE_SHA1;
8445                    salt_type   = SALT_TYPE_EMBEDDED;
8446                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8448                                | OPTS_TYPE_PT_ADD80
8449                                | OPTS_TYPE_PT_ADDBITS15
8450                                | OPTS_TYPE_PT_UNICODE
8451                                | OPTS_TYPE_ST_BASE64;
8452                    kern_type   = KERN_TYPE_SHA1_SLTPWU;
8453                    dgst_size   = DGST_SIZE_4_5;
8454                    parse_func  = episerver_parse_hash;
8455                    sort_by_digest = sort_by_digest_4_5;
8456                    opti_type   = OPTI_TYPE_ZERO_BYTE
8457                                | OPTI_TYPE_PRECOMPUTE_INIT
8458                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8459                                | OPTI_TYPE_EARLY_SKIP
8460                                | OPTI_TYPE_NOT_ITERATED
8461                                | OPTI_TYPE_PREPENDED_SALT
8462                                | OPTI_TYPE_RAW_HASH;
8463                    dgst_pos0   = 3;
8464                    dgst_pos1   = 4;
8465                    dgst_pos2   = 2;
8466                    dgst_pos3   = 1;
8467                    break;
8468
8469       case   150:  hash_type   = HASH_TYPE_SHA1;
8470                    salt_type   = SALT_TYPE_INTERN;
8471                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8472                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8473                                | OPTS_TYPE_ST_ADD80
8474                                | OPTS_TYPE_ST_ADDBITS15;
8475                    kern_type   = KERN_TYPE_HMACSHA1_PW;
8476                    dgst_size   = DGST_SIZE_4_5;
8477                    parse_func  = hmacsha1_parse_hash;
8478                    sort_by_digest = sort_by_digest_4_5;
8479                    opti_type   = OPTI_TYPE_ZERO_BYTE
8480                                | OPTI_TYPE_NOT_ITERATED;
8481                    dgst_pos0   = 3;
8482                    dgst_pos1   = 4;
8483                    dgst_pos2   = 2;
8484                    dgst_pos3   = 1;
8485                    break;
8486
8487       case   160:  hash_type   = HASH_TYPE_SHA1;
8488                    salt_type   = SALT_TYPE_INTERN;
8489                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8491                                | OPTS_TYPE_PT_ADD80
8492                                | OPTS_TYPE_PT_ADDBITS15;
8493                    kern_type   = KERN_TYPE_HMACSHA1_SLT;
8494                    dgst_size   = DGST_SIZE_4_5;
8495                    parse_func  = hmacsha1_parse_hash;
8496                    sort_by_digest = sort_by_digest_4_5;
8497                    opti_type   = OPTI_TYPE_ZERO_BYTE
8498                                | OPTI_TYPE_NOT_ITERATED;
8499                    dgst_pos0   = 3;
8500                    dgst_pos1   = 4;
8501                    dgst_pos2   = 2;
8502                    dgst_pos3   = 1;
8503                    break;
8504
8505       case   200:  hash_type   = HASH_TYPE_MYSQL;
8506                    salt_type   = SALT_TYPE_NONE;
8507                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508                    opts_type   = 0;
8509                    kern_type   = KERN_TYPE_MYSQL;
8510                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8511                    parse_func  = mysql323_parse_hash;
8512                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8513                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8514                    dgst_pos0   = 0;
8515                    dgst_pos1   = 1;
8516                    dgst_pos2   = 2;
8517                    dgst_pos3   = 3;
8518                    break;
8519
8520       case   300:  hash_type   = HASH_TYPE_SHA1;
8521                    salt_type   = SALT_TYPE_NONE;
8522                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8524                                | OPTS_TYPE_PT_ADD80
8525                                | OPTS_TYPE_PT_ADDBITS15;
8526                    kern_type   = KERN_TYPE_MYSQL41;
8527                    dgst_size   = DGST_SIZE_4_5;
8528                    parse_func  = sha1_parse_hash;
8529                    sort_by_digest = sort_by_digest_4_5;
8530                    opti_type   = OPTI_TYPE_ZERO_BYTE
8531                                | OPTI_TYPE_PRECOMPUTE_INIT
8532                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8533                                | OPTI_TYPE_EARLY_SKIP
8534                                | OPTI_TYPE_NOT_ITERATED
8535                                | OPTI_TYPE_NOT_SALTED;
8536                    dgst_pos0   = 3;
8537                    dgst_pos1   = 4;
8538                    dgst_pos2   = 2;
8539                    dgst_pos3   = 1;
8540                    break;
8541
8542       case   400:  hash_type   = HASH_TYPE_MD5;
8543                    salt_type   = SALT_TYPE_EMBEDDED;
8544                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8545                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8546                    kern_type   = KERN_TYPE_PHPASS;
8547                    dgst_size   = DGST_SIZE_4_4;
8548                    parse_func  = phpass_parse_hash;
8549                    sort_by_digest = sort_by_digest_4_4;
8550                    opti_type   = OPTI_TYPE_ZERO_BYTE
8551                                | OPTI_TYPE_SLOW_HASH_SIMD;
8552                    dgst_pos0   = 0;
8553                    dgst_pos1   = 1;
8554                    dgst_pos2   = 2;
8555                    dgst_pos3   = 3;
8556                    break;
8557
8558       case   500:  hash_type   = HASH_TYPE_MD5;
8559                    salt_type   = SALT_TYPE_EMBEDDED;
8560                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8562                    kern_type   = KERN_TYPE_MD5CRYPT;
8563                    dgst_size   = DGST_SIZE_4_4;
8564                    parse_func  = md5crypt_parse_hash;
8565                    sort_by_digest = sort_by_digest_4_4;
8566                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8567                    dgst_pos0   = 0;
8568                    dgst_pos1   = 1;
8569                    dgst_pos2   = 2;
8570                    dgst_pos3   = 3;
8571                    break;
8572
8573       case   501:  hash_type   = HASH_TYPE_MD5;
8574                    salt_type   = SALT_TYPE_EMBEDDED;
8575                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8576                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8577                                | OPTS_TYPE_HASH_COPY;
8578                    kern_type   = KERN_TYPE_MD5CRYPT;
8579                    dgst_size   = DGST_SIZE_4_4;
8580                    parse_func  = juniper_parse_hash;
8581                    sort_by_digest = sort_by_digest_4_4;
8582                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8583                    dgst_pos0   = 0;
8584                    dgst_pos1   = 1;
8585                    dgst_pos2   = 2;
8586                    dgst_pos3   = 3;
8587                    break;
8588
8589       case   900:  hash_type   = HASH_TYPE_MD4;
8590                    salt_type   = SALT_TYPE_NONE;
8591                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8593                                | OPTS_TYPE_PT_ADD80
8594                                | OPTS_TYPE_PT_ADDBITS14;
8595                    kern_type   = KERN_TYPE_MD4;
8596                    dgst_size   = DGST_SIZE_4_4;
8597                    parse_func  = md4_parse_hash;
8598                    sort_by_digest = sort_by_digest_4_4;
8599                    opti_type   = OPTI_TYPE_ZERO_BYTE
8600                                | OPTI_TYPE_PRECOMPUTE_INIT
8601                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8602                                | OPTI_TYPE_MEET_IN_MIDDLE
8603                                | OPTI_TYPE_EARLY_SKIP
8604                                | OPTI_TYPE_NOT_ITERATED
8605                                | OPTI_TYPE_NOT_SALTED
8606                                | OPTI_TYPE_RAW_HASH;
8607                    dgst_pos0   = 0;
8608                    dgst_pos1   = 3;
8609                    dgst_pos2   = 2;
8610                    dgst_pos3   = 1;
8611                    break;
8612
8613       case  1000:  hash_type   = HASH_TYPE_MD4;
8614                    salt_type   = SALT_TYPE_NONE;
8615                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8617                                | OPTS_TYPE_PT_ADD80
8618                                | OPTS_TYPE_PT_ADDBITS14
8619                                | OPTS_TYPE_PT_UNICODE;
8620                    kern_type   = KERN_TYPE_MD4_PWU;
8621                    dgst_size   = DGST_SIZE_4_4;
8622                    parse_func  = md4_parse_hash;
8623                    sort_by_digest = sort_by_digest_4_4;
8624                    opti_type   = OPTI_TYPE_ZERO_BYTE
8625                                | OPTI_TYPE_PRECOMPUTE_INIT
8626                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8627                                | OPTI_TYPE_MEET_IN_MIDDLE
8628                                | OPTI_TYPE_EARLY_SKIP
8629                                | OPTI_TYPE_NOT_ITERATED
8630                                | OPTI_TYPE_NOT_SALTED
8631                                | OPTI_TYPE_RAW_HASH;
8632                    dgst_pos0   = 0;
8633                    dgst_pos1   = 3;
8634                    dgst_pos2   = 2;
8635                    dgst_pos3   = 1;
8636                    break;
8637
8638       case  1100:  hash_type   = HASH_TYPE_MD4;
8639                    salt_type   = SALT_TYPE_INTERN;
8640                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8642                                | OPTS_TYPE_PT_ADD80
8643                                | OPTS_TYPE_PT_ADDBITS14
8644                                | OPTS_TYPE_PT_UNICODE
8645                                | OPTS_TYPE_ST_ADD80
8646                                | OPTS_TYPE_ST_UNICODE
8647                                | OPTS_TYPE_ST_LOWER;
8648                    kern_type   = KERN_TYPE_MD44_PWUSLT;
8649                    dgst_size   = DGST_SIZE_4_4;
8650                    parse_func  = dcc_parse_hash;
8651                    sort_by_digest = sort_by_digest_4_4;
8652                    opti_type   = OPTI_TYPE_ZERO_BYTE
8653                                | OPTI_TYPE_PRECOMPUTE_INIT
8654                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8655                                | OPTI_TYPE_EARLY_SKIP
8656                                | OPTI_TYPE_NOT_ITERATED;
8657                    dgst_pos0   = 0;
8658                    dgst_pos1   = 3;
8659                    dgst_pos2   = 2;
8660                    dgst_pos3   = 1;
8661                    break;
8662
8663       case  1400:  hash_type   = HASH_TYPE_SHA256;
8664                    salt_type   = SALT_TYPE_NONE;
8665                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8667                                | OPTS_TYPE_PT_ADD80
8668                                | OPTS_TYPE_PT_ADDBITS15;
8669                    kern_type   = KERN_TYPE_SHA256;
8670                    dgst_size   = DGST_SIZE_4_8;
8671                    parse_func  = sha256_parse_hash;
8672                    sort_by_digest = sort_by_digest_4_8;
8673                    opti_type   = OPTI_TYPE_ZERO_BYTE
8674                                | OPTI_TYPE_PRECOMPUTE_INIT
8675                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8676                                | OPTI_TYPE_EARLY_SKIP
8677                                | OPTI_TYPE_NOT_ITERATED
8678                                | OPTI_TYPE_NOT_SALTED
8679                                | OPTI_TYPE_RAW_HASH;
8680                    dgst_pos0   = 3;
8681                    dgst_pos1   = 7;
8682                    dgst_pos2   = 2;
8683                    dgst_pos3   = 6;
8684                    break;
8685
8686       case  1410:  hash_type   = HASH_TYPE_SHA256;
8687                    salt_type   = SALT_TYPE_INTERN;
8688                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8690                                | OPTS_TYPE_ST_ADD80
8691                                | OPTS_TYPE_ST_ADDBITS15;
8692                    kern_type   = KERN_TYPE_SHA256_PWSLT;
8693                    dgst_size   = DGST_SIZE_4_8;
8694                    parse_func  = sha256s_parse_hash;
8695                    sort_by_digest = sort_by_digest_4_8;
8696                    opti_type   = OPTI_TYPE_ZERO_BYTE
8697                                | OPTI_TYPE_PRECOMPUTE_INIT
8698                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8699                                | OPTI_TYPE_EARLY_SKIP
8700                                | OPTI_TYPE_NOT_ITERATED
8701                                | OPTI_TYPE_APPENDED_SALT
8702                                | OPTI_TYPE_RAW_HASH;
8703                    dgst_pos0   = 3;
8704                    dgst_pos1   = 7;
8705                    dgst_pos2   = 2;
8706                    dgst_pos3   = 6;
8707                    break;
8708
8709       case  1420:  hash_type   = HASH_TYPE_SHA256;
8710                    salt_type   = SALT_TYPE_INTERN;
8711                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8713                                | OPTS_TYPE_PT_ADD80
8714                                | OPTS_TYPE_PT_ADDBITS15;
8715                    kern_type   = KERN_TYPE_SHA256_SLTPW;
8716                    dgst_size   = DGST_SIZE_4_8;
8717                    parse_func  = sha256s_parse_hash;
8718                    sort_by_digest = sort_by_digest_4_8;
8719                    opti_type   = OPTI_TYPE_ZERO_BYTE
8720                                | OPTI_TYPE_PRECOMPUTE_INIT
8721                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8722                                | OPTI_TYPE_EARLY_SKIP
8723                                | OPTI_TYPE_NOT_ITERATED
8724                                | OPTI_TYPE_PREPENDED_SALT
8725                                | OPTI_TYPE_RAW_HASH;
8726                    dgst_pos0   = 3;
8727                    dgst_pos1   = 7;
8728                    dgst_pos2   = 2;
8729                    dgst_pos3   = 6;
8730                    break;
8731
8732       case  1421:  hash_type   = HASH_TYPE_SHA256;
8733                    salt_type   = SALT_TYPE_EMBEDDED;
8734                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8736                                | OPTS_TYPE_PT_ADD80
8737                                | OPTS_TYPE_PT_ADDBITS15;
8738                    kern_type   = KERN_TYPE_SHA256_SLTPW;
8739                    dgst_size   = DGST_SIZE_4_8;
8740                    parse_func  = hmailserver_parse_hash;
8741                    sort_by_digest = sort_by_digest_4_8;
8742                    opti_type   = OPTI_TYPE_ZERO_BYTE
8743                                | OPTI_TYPE_PRECOMPUTE_INIT
8744                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8745                                | OPTI_TYPE_EARLY_SKIP
8746                                | OPTI_TYPE_NOT_ITERATED
8747                                | OPTI_TYPE_PREPENDED_SALT
8748                                | OPTI_TYPE_RAW_HASH;
8749                    dgst_pos0   = 3;
8750                    dgst_pos1   = 7;
8751                    dgst_pos2   = 2;
8752                    dgst_pos3   = 6;
8753                    break;
8754
8755       case  1430:  hash_type   = HASH_TYPE_SHA256;
8756                    salt_type   = SALT_TYPE_INTERN;
8757                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8759                                | OPTS_TYPE_PT_UNICODE
8760                                | OPTS_TYPE_ST_ADD80
8761                                | OPTS_TYPE_ST_ADDBITS15;
8762                    kern_type   = KERN_TYPE_SHA256_PWUSLT;
8763                    dgst_size   = DGST_SIZE_4_8;
8764                    parse_func  = sha256s_parse_hash;
8765                    sort_by_digest = sort_by_digest_4_8;
8766                    opti_type   = OPTI_TYPE_ZERO_BYTE
8767                                | OPTI_TYPE_PRECOMPUTE_INIT
8768                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8769                                | OPTI_TYPE_EARLY_SKIP
8770                                | OPTI_TYPE_NOT_ITERATED
8771                                | OPTI_TYPE_APPENDED_SALT
8772                                | OPTI_TYPE_RAW_HASH;
8773                    dgst_pos0   = 3;
8774                    dgst_pos1   = 7;
8775                    dgst_pos2   = 2;
8776                    dgst_pos3   = 6;
8777                    break;
8778
8779       case  1440:  hash_type   = HASH_TYPE_SHA256;
8780                    salt_type   = SALT_TYPE_INTERN;
8781                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8783                                | OPTS_TYPE_PT_ADD80
8784                                | OPTS_TYPE_PT_ADDBITS15
8785                                | OPTS_TYPE_PT_UNICODE;
8786                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8787                    dgst_size   = DGST_SIZE_4_8;
8788                    parse_func  = sha256s_parse_hash;
8789                    sort_by_digest = sort_by_digest_4_8;
8790                    opti_type   = OPTI_TYPE_ZERO_BYTE
8791                                | OPTI_TYPE_PRECOMPUTE_INIT
8792                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8793                                | OPTI_TYPE_EARLY_SKIP
8794                                | OPTI_TYPE_NOT_ITERATED
8795                                | OPTI_TYPE_PREPENDED_SALT
8796                                | OPTI_TYPE_RAW_HASH;
8797                    dgst_pos0   = 3;
8798                    dgst_pos1   = 7;
8799                    dgst_pos2   = 2;
8800                    dgst_pos3   = 6;
8801                    break;
8802
8803       case  1441:  hash_type   = HASH_TYPE_SHA256;
8804                    salt_type   = SALT_TYPE_EMBEDDED;
8805                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8806                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8807                                | OPTS_TYPE_PT_ADD80
8808                                | OPTS_TYPE_PT_ADDBITS15
8809                                | OPTS_TYPE_PT_UNICODE
8810                                | OPTS_TYPE_ST_BASE64;
8811                    kern_type   = KERN_TYPE_SHA256_SLTPWU;
8812                    dgst_size   = DGST_SIZE_4_8;
8813                    parse_func  = episerver4_parse_hash;
8814                    sort_by_digest = sort_by_digest_4_8;
8815                    opti_type   = OPTI_TYPE_ZERO_BYTE
8816                                | OPTI_TYPE_PRECOMPUTE_INIT
8817                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8818                                | OPTI_TYPE_EARLY_SKIP
8819                                | OPTI_TYPE_NOT_ITERATED
8820                                | OPTI_TYPE_PREPENDED_SALT
8821                                | OPTI_TYPE_RAW_HASH;
8822                    dgst_pos0   = 3;
8823                    dgst_pos1   = 7;
8824                    dgst_pos2   = 2;
8825                    dgst_pos3   = 6;
8826                    break;
8827
8828       case  1450:  hash_type   = HASH_TYPE_SHA256;
8829                    salt_type   = SALT_TYPE_INTERN;
8830                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8832                                | OPTS_TYPE_ST_ADD80;
8833                    kern_type   = KERN_TYPE_HMACSHA256_PW;
8834                    dgst_size   = DGST_SIZE_4_8;
8835                    parse_func  = hmacsha256_parse_hash;
8836                    sort_by_digest = sort_by_digest_4_8;
8837                    opti_type   = OPTI_TYPE_ZERO_BYTE
8838                                | OPTI_TYPE_NOT_ITERATED;
8839                    dgst_pos0   = 3;
8840                    dgst_pos1   = 7;
8841                    dgst_pos2   = 2;
8842                    dgst_pos3   = 6;
8843                    break;
8844
8845       case  1460:  hash_type   = HASH_TYPE_SHA256;
8846                    salt_type   = SALT_TYPE_INTERN;
8847                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8849                                | OPTS_TYPE_PT_ADD80
8850                                | OPTS_TYPE_PT_ADDBITS15;
8851                    kern_type   = KERN_TYPE_HMACSHA256_SLT;
8852                    dgst_size   = DGST_SIZE_4_8;
8853                    parse_func  = hmacsha256_parse_hash;
8854                    sort_by_digest = sort_by_digest_4_8;
8855                    opti_type   = OPTI_TYPE_ZERO_BYTE
8856                                | OPTI_TYPE_NOT_ITERATED;
8857                    dgst_pos0   = 3;
8858                    dgst_pos1   = 7;
8859                    dgst_pos2   = 2;
8860                    dgst_pos3   = 6;
8861                    break;
8862
8863       case  1500:  hash_type   = HASH_TYPE_DESCRYPT;
8864                    salt_type   = SALT_TYPE_EMBEDDED;
8865                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8866                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
8867                                | OPTS_TYPE_PT_BITSLICE;
8868                    kern_type   = KERN_TYPE_DESCRYPT;
8869                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8870                    parse_func  = descrypt_parse_hash;
8871                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8872                    opti_type   = OPTI_TYPE_ZERO_BYTE
8873                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
8874                    dgst_pos0   = 0;
8875                    dgst_pos1   = 1;
8876                    dgst_pos2   = 2;
8877                    dgst_pos3   = 3;
8878                    break;
8879
8880       case  1600:  hash_type   = HASH_TYPE_MD5;
8881                    salt_type   = SALT_TYPE_EMBEDDED;
8882                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
8884                    kern_type   = KERN_TYPE_APR1CRYPT;
8885                    dgst_size   = DGST_SIZE_4_4;
8886                    parse_func  = md5apr1_parse_hash;
8887                    sort_by_digest = sort_by_digest_4_4;
8888                    opti_type   = OPTI_TYPE_ZERO_BYTE;
8889                    dgst_pos0   = 0;
8890                    dgst_pos1   = 1;
8891                    dgst_pos2   = 2;
8892                    dgst_pos3   = 3;
8893                    break;
8894
8895       case  1700:  hash_type   = HASH_TYPE_SHA512;
8896                    salt_type   = SALT_TYPE_NONE;
8897                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8899                                | OPTS_TYPE_PT_ADD80
8900                                | OPTS_TYPE_PT_ADDBITS15;
8901                    kern_type   = KERN_TYPE_SHA512;
8902                    dgst_size   = DGST_SIZE_8_8;
8903                    parse_func  = sha512_parse_hash;
8904                    sort_by_digest = sort_by_digest_8_8;
8905                    opti_type   = OPTI_TYPE_ZERO_BYTE
8906                                | OPTI_TYPE_PRECOMPUTE_INIT
8907                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8908                                | OPTI_TYPE_EARLY_SKIP
8909                                | OPTI_TYPE_NOT_ITERATED
8910                                | OPTI_TYPE_NOT_SALTED
8911                                | OPTI_TYPE_USES_BITS_64
8912                                | OPTI_TYPE_RAW_HASH;
8913                    dgst_pos0   = 14;
8914                    dgst_pos1   = 15;
8915                    dgst_pos2   = 6;
8916                    dgst_pos3   = 7;
8917                    break;
8918
8919       case  1710:  hash_type   = HASH_TYPE_SHA512;
8920                    salt_type   = SALT_TYPE_INTERN;
8921                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8922                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8923                                | OPTS_TYPE_ST_ADD80
8924                                | OPTS_TYPE_ST_ADDBITS15;
8925                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8926                    dgst_size   = DGST_SIZE_8_8;
8927                    parse_func  = sha512s_parse_hash;
8928                    sort_by_digest = sort_by_digest_8_8;
8929                    opti_type   = OPTI_TYPE_ZERO_BYTE
8930                                | OPTI_TYPE_PRECOMPUTE_INIT
8931                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8932                                | OPTI_TYPE_EARLY_SKIP
8933                                | OPTI_TYPE_NOT_ITERATED
8934                                | OPTI_TYPE_APPENDED_SALT
8935                                | OPTI_TYPE_USES_BITS_64
8936                                | OPTI_TYPE_RAW_HASH;
8937                    dgst_pos0   = 14;
8938                    dgst_pos1   = 15;
8939                    dgst_pos2   = 6;
8940                    dgst_pos3   = 7;
8941                    break;
8942
8943       case  1711:  hash_type   = HASH_TYPE_SHA512;
8944                    salt_type   = SALT_TYPE_EMBEDDED;
8945                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8947                                | OPTS_TYPE_ST_ADD80
8948                                | OPTS_TYPE_ST_ADDBITS15;
8949                    kern_type   = KERN_TYPE_SHA512_PWSLT;
8950                    dgst_size   = DGST_SIZE_8_8;
8951                    parse_func  = sha512b64s_parse_hash;
8952                    sort_by_digest = sort_by_digest_8_8;
8953                    opti_type   = OPTI_TYPE_ZERO_BYTE
8954                                | OPTI_TYPE_PRECOMPUTE_INIT
8955                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8956                                | OPTI_TYPE_EARLY_SKIP
8957                                | OPTI_TYPE_NOT_ITERATED
8958                                | OPTI_TYPE_APPENDED_SALT
8959                                | OPTI_TYPE_USES_BITS_64
8960                                | OPTI_TYPE_RAW_HASH;
8961                    dgst_pos0   = 14;
8962                    dgst_pos1   = 15;
8963                    dgst_pos2   = 6;
8964                    dgst_pos3   = 7;
8965                    break;
8966
8967       case  1720:  hash_type   = HASH_TYPE_SHA512;
8968                    salt_type   = SALT_TYPE_INTERN;
8969                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8971                                | OPTS_TYPE_PT_ADD80
8972                                | OPTS_TYPE_PT_ADDBITS15;
8973                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8974                    dgst_size   = DGST_SIZE_8_8;
8975                    parse_func  = sha512s_parse_hash;
8976                    sort_by_digest = sort_by_digest_8_8;
8977                    opti_type   = OPTI_TYPE_ZERO_BYTE
8978                                | OPTI_TYPE_PRECOMPUTE_INIT
8979                                | OPTI_TYPE_PRECOMPUTE_MERKLE
8980                                | OPTI_TYPE_EARLY_SKIP
8981                                | OPTI_TYPE_NOT_ITERATED
8982                                | OPTI_TYPE_PREPENDED_SALT
8983                                | OPTI_TYPE_USES_BITS_64
8984                                | OPTI_TYPE_RAW_HASH;
8985                    dgst_pos0   = 14;
8986                    dgst_pos1   = 15;
8987                    dgst_pos2   = 6;
8988                    dgst_pos3   = 7;
8989                    break;
8990
8991       case  1722:  hash_type   = HASH_TYPE_SHA512;
8992                    salt_type   = SALT_TYPE_EMBEDDED;
8993                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8994                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
8995                                | OPTS_TYPE_PT_ADD80
8996                                | OPTS_TYPE_PT_ADDBITS15
8997                                | OPTS_TYPE_ST_HEX;
8998                    kern_type   = KERN_TYPE_SHA512_SLTPW;
8999                    dgst_size   = DGST_SIZE_8_8;
9000                    parse_func  = osx512_parse_hash;
9001                    sort_by_digest = sort_by_digest_8_8;
9002                    opti_type   = OPTI_TYPE_ZERO_BYTE
9003                                | OPTI_TYPE_PRECOMPUTE_INIT
9004                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9005                                | OPTI_TYPE_EARLY_SKIP
9006                                | OPTI_TYPE_NOT_ITERATED
9007                                | OPTI_TYPE_PREPENDED_SALT
9008                                | OPTI_TYPE_USES_BITS_64
9009                                | OPTI_TYPE_RAW_HASH;
9010                    dgst_pos0   = 14;
9011                    dgst_pos1   = 15;
9012                    dgst_pos2   = 6;
9013                    dgst_pos3   = 7;
9014                    break;
9015
9016       case  1730:  hash_type   = HASH_TYPE_SHA512;
9017                    salt_type   = SALT_TYPE_INTERN;
9018                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9019                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9020                                | OPTS_TYPE_PT_UNICODE
9021                                | OPTS_TYPE_ST_ADD80
9022                                | OPTS_TYPE_ST_ADDBITS15;
9023                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
9024                    dgst_size   = DGST_SIZE_8_8;
9025                    parse_func  = sha512s_parse_hash;
9026                    sort_by_digest = sort_by_digest_8_8;
9027                    opti_type   = OPTI_TYPE_ZERO_BYTE
9028                                | OPTI_TYPE_PRECOMPUTE_INIT
9029                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9030                                | OPTI_TYPE_EARLY_SKIP
9031                                | OPTI_TYPE_NOT_ITERATED
9032                                | OPTI_TYPE_APPENDED_SALT
9033                                | OPTI_TYPE_USES_BITS_64
9034                                | OPTI_TYPE_RAW_HASH;
9035                    dgst_pos0   = 14;
9036                    dgst_pos1   = 15;
9037                    dgst_pos2   = 6;
9038                    dgst_pos3   = 7;
9039                    break;
9040
9041       case  1731:  hash_type   = HASH_TYPE_SHA512;
9042                    salt_type   = SALT_TYPE_EMBEDDED;
9043                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9044                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9045                                | OPTS_TYPE_PT_UNICODE
9046                                | OPTS_TYPE_ST_ADD80
9047                                | OPTS_TYPE_ST_ADDBITS15
9048                                | OPTS_TYPE_ST_HEX;
9049                    kern_type   = KERN_TYPE_SHA512_PWSLTU;
9050                    dgst_size   = DGST_SIZE_8_8;
9051                    parse_func  = mssql2012_parse_hash;
9052                    sort_by_digest = sort_by_digest_8_8;
9053                    opti_type   = OPTI_TYPE_ZERO_BYTE
9054                                | OPTI_TYPE_PRECOMPUTE_INIT
9055                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9056                                | OPTI_TYPE_EARLY_SKIP
9057                                | OPTI_TYPE_NOT_ITERATED
9058                                | OPTI_TYPE_APPENDED_SALT
9059                                | OPTI_TYPE_USES_BITS_64
9060                                | OPTI_TYPE_RAW_HASH;
9061                    dgst_pos0   = 14;
9062                    dgst_pos1   = 15;
9063                    dgst_pos2   = 6;
9064                    dgst_pos3   = 7;
9065                    break;
9066
9067       case  1740:  hash_type   = HASH_TYPE_SHA512;
9068                    salt_type   = SALT_TYPE_INTERN;
9069                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9070                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9071                                | OPTS_TYPE_PT_ADD80
9072                                | OPTS_TYPE_PT_ADDBITS15
9073                                | OPTS_TYPE_PT_UNICODE;
9074                    kern_type   = KERN_TYPE_SHA512_SLTPWU;
9075                    dgst_size   = DGST_SIZE_8_8;
9076                    parse_func  = sha512s_parse_hash;
9077                    sort_by_digest = sort_by_digest_8_8;
9078                    opti_type   = OPTI_TYPE_ZERO_BYTE
9079                                | OPTI_TYPE_PRECOMPUTE_INIT
9080                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9081                                | OPTI_TYPE_EARLY_SKIP
9082                                | OPTI_TYPE_NOT_ITERATED
9083                                | OPTI_TYPE_PREPENDED_SALT
9084                                | OPTI_TYPE_USES_BITS_64
9085                                | OPTI_TYPE_RAW_HASH;
9086                    dgst_pos0   = 14;
9087                    dgst_pos1   = 15;
9088                    dgst_pos2   = 6;
9089                    dgst_pos3   = 7;
9090                    break;
9091
9092       case  1750:  hash_type   = HASH_TYPE_SHA512;
9093                    salt_type   = SALT_TYPE_INTERN;
9094                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9095                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9096                                | OPTS_TYPE_ST_ADD80;
9097                    kern_type   = KERN_TYPE_HMACSHA512_PW;
9098                    dgst_size   = DGST_SIZE_8_8;
9099                    parse_func  = hmacsha512_parse_hash;
9100                    sort_by_digest = sort_by_digest_8_8;
9101                    opti_type   = OPTI_TYPE_ZERO_BYTE
9102                                | OPTI_TYPE_USES_BITS_64
9103                                | OPTI_TYPE_NOT_ITERATED;
9104                    dgst_pos0   = 14;
9105                    dgst_pos1   = 15;
9106                    dgst_pos2   = 6;
9107                    dgst_pos3   = 7;
9108                    break;
9109
9110       case  1760:  hash_type   = HASH_TYPE_SHA512;
9111                    salt_type   = SALT_TYPE_INTERN;
9112                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9113                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9114                                | OPTS_TYPE_PT_ADD80
9115                                | OPTS_TYPE_PT_ADDBITS15;
9116                    kern_type   = KERN_TYPE_HMACSHA512_SLT;
9117                    dgst_size   = DGST_SIZE_8_8;
9118                    parse_func  = hmacsha512_parse_hash;
9119                    sort_by_digest = sort_by_digest_8_8;
9120                    opti_type   = OPTI_TYPE_ZERO_BYTE
9121                                | OPTI_TYPE_USES_BITS_64
9122                                | OPTI_TYPE_NOT_ITERATED;
9123                    dgst_pos0   = 14;
9124                    dgst_pos1   = 15;
9125                    dgst_pos2   = 6;
9126                    dgst_pos3   = 7;
9127                    break;
9128
9129       case  1800:  hash_type   = HASH_TYPE_SHA512;
9130                    salt_type   = SALT_TYPE_EMBEDDED;
9131                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9132                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9133                    kern_type   = KERN_TYPE_SHA512CRYPT;
9134                    dgst_size   = DGST_SIZE_8_8;
9135                    parse_func  = sha512crypt_parse_hash;
9136                    sort_by_digest = sort_by_digest_8_8;
9137                    opti_type   = OPTI_TYPE_ZERO_BYTE
9138                                | OPTI_TYPE_USES_BITS_64;
9139                    dgst_pos0   = 0;
9140                    dgst_pos1   = 1;
9141                    dgst_pos2   = 2;
9142                    dgst_pos3   = 3;
9143                    break;
9144
9145       case  2000:  hash_type   = HASH_TYPE_STDOUT;
9146                    salt_type   = SALT_TYPE_NONE;
9147                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9149                    kern_type   = KERN_TYPE_STDOUT;
9150                    dgst_size   = DGST_SIZE_4_4;
9151                    parse_func  = NULL;
9152                    sort_by_digest = NULL;
9153                    opti_type   = 0;
9154                    dgst_pos0   = 0;
9155                    dgst_pos1   = 0;
9156                    dgst_pos2   = 0;
9157                    dgst_pos3   = 0;
9158                    break;
9159
9160       case  2100:  hash_type   = HASH_TYPE_DCC2;
9161                    salt_type   = SALT_TYPE_EMBEDDED;
9162                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9163                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
9164                                | OPTS_TYPE_ST_LOWER
9165                                | OPTS_TYPE_ST_UNICODE;
9166                    kern_type   = KERN_TYPE_DCC2;
9167                    dgst_size   = DGST_SIZE_4_4;
9168                    parse_func  = dcc2_parse_hash;
9169                    sort_by_digest = sort_by_digest_4_4;
9170                    opti_type   = OPTI_TYPE_ZERO_BYTE
9171                                | OPTI_TYPE_SLOW_HASH_SIMD;
9172                    dgst_pos0   = 0;
9173                    dgst_pos1   = 1;
9174                    dgst_pos2   = 2;
9175                    dgst_pos3   = 3;
9176                    break;
9177
9178       case  2400:  hash_type   = HASH_TYPE_MD5;
9179                    salt_type   = SALT_TYPE_NONE;
9180                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9182                    kern_type   = KERN_TYPE_MD5PIX;
9183                    dgst_size   = DGST_SIZE_4_4;
9184                    parse_func  = md5pix_parse_hash;
9185                    sort_by_digest = sort_by_digest_4_4;
9186                    opti_type   = OPTI_TYPE_ZERO_BYTE
9187                                | OPTI_TYPE_PRECOMPUTE_INIT
9188                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9189                                | OPTI_TYPE_EARLY_SKIP
9190                                | OPTI_TYPE_NOT_ITERATED
9191                                | OPTI_TYPE_NOT_SALTED;
9192                    dgst_pos0   = 0;
9193                    dgst_pos1   = 3;
9194                    dgst_pos2   = 2;
9195                    dgst_pos3   = 1;
9196                    break;
9197
9198       case  2410:  hash_type   = HASH_TYPE_MD5;
9199                    salt_type   = SALT_TYPE_INTERN;
9200                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9201                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9202                    kern_type   = KERN_TYPE_MD5ASA;
9203                    dgst_size   = DGST_SIZE_4_4;
9204                    parse_func  = md5asa_parse_hash;
9205                    sort_by_digest = sort_by_digest_4_4;
9206                    opti_type   = OPTI_TYPE_ZERO_BYTE
9207                                | OPTI_TYPE_PRECOMPUTE_INIT
9208                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9209                                | OPTI_TYPE_EARLY_SKIP
9210                                | OPTI_TYPE_NOT_ITERATED;
9211                    dgst_pos0   = 0;
9212                    dgst_pos1   = 3;
9213                    dgst_pos2   = 2;
9214                    dgst_pos3   = 1;
9215                    break;
9216
9217       case  2500:  hash_type   = HASH_TYPE_WPA;
9218                    salt_type   = SALT_TYPE_EMBEDDED;
9219                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221                    kern_type   = KERN_TYPE_WPA;
9222                    dgst_size   = DGST_SIZE_4_4;
9223                    parse_func  = wpa_parse_hash;
9224                    sort_by_digest = sort_by_digest_4_4;
9225                    opti_type   = OPTI_TYPE_ZERO_BYTE
9226                                | OPTI_TYPE_SLOW_HASH_SIMD;
9227                    dgst_pos0   = 0;
9228                    dgst_pos1   = 1;
9229                    dgst_pos2   = 2;
9230                    dgst_pos3   = 3;
9231                    break;
9232
9233       case  2600:  hash_type   = HASH_TYPE_MD5;
9234                    salt_type   = SALT_TYPE_VIRTUAL;
9235                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9237                                | OPTS_TYPE_PT_ADD80
9238                                | OPTS_TYPE_PT_ADDBITS14
9239                                | OPTS_TYPE_ST_ADD80;
9240                    kern_type   = KERN_TYPE_MD55_PWSLT1;
9241                    dgst_size   = DGST_SIZE_4_4;
9242                    parse_func  = md5md5_parse_hash;
9243                    sort_by_digest = sort_by_digest_4_4;
9244                    opti_type   = OPTI_TYPE_ZERO_BYTE
9245                                | OPTI_TYPE_PRECOMPUTE_INIT
9246                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9247                                | OPTI_TYPE_EARLY_SKIP;
9248                    dgst_pos0   = 0;
9249                    dgst_pos1   = 3;
9250                    dgst_pos2   = 2;
9251                    dgst_pos3   = 1;
9252                    break;
9253
9254       case  2611:  hash_type   = HASH_TYPE_MD5;
9255                    salt_type   = SALT_TYPE_INTERN;
9256                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9258                                | OPTS_TYPE_PT_ADD80
9259                                | OPTS_TYPE_PT_ADDBITS14
9260                                | OPTS_TYPE_ST_ADD80;
9261                    kern_type   = KERN_TYPE_MD55_PWSLT1;
9262                    dgst_size   = DGST_SIZE_4_4;
9263                    parse_func  = vb3_parse_hash;
9264                    sort_by_digest = sort_by_digest_4_4;
9265                    opti_type   = OPTI_TYPE_ZERO_BYTE
9266                                | OPTI_TYPE_PRECOMPUTE_INIT
9267                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9268                                | OPTI_TYPE_EARLY_SKIP;
9269                    dgst_pos0   = 0;
9270                    dgst_pos1   = 3;
9271                    dgst_pos2   = 2;
9272                    dgst_pos3   = 1;
9273                    break;
9274
9275       case  2612:  hash_type   = HASH_TYPE_MD5;
9276                    salt_type   = SALT_TYPE_EMBEDDED;
9277                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9278                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9279                                | OPTS_TYPE_PT_ADD80
9280                                | OPTS_TYPE_PT_ADDBITS14
9281                                | OPTS_TYPE_ST_ADD80
9282                                | OPTS_TYPE_ST_HEX;
9283                    kern_type   = KERN_TYPE_MD55_PWSLT1;
9284                    dgst_size   = DGST_SIZE_4_4;
9285                    parse_func  = phps_parse_hash;
9286                    sort_by_digest = sort_by_digest_4_4;
9287                    opti_type   = OPTI_TYPE_ZERO_BYTE
9288                                | OPTI_TYPE_PRECOMPUTE_INIT
9289                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9290                                | OPTI_TYPE_EARLY_SKIP;
9291                    dgst_pos0   = 0;
9292                    dgst_pos1   = 3;
9293                    dgst_pos2   = 2;
9294                    dgst_pos3   = 1;
9295                    break;
9296
9297       case  2711:  hash_type   = HASH_TYPE_MD5;
9298                    salt_type   = SALT_TYPE_INTERN;
9299                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9301                                | OPTS_TYPE_PT_ADD80
9302                                | OPTS_TYPE_PT_ADDBITS14
9303                                | OPTS_TYPE_ST_ADD80;
9304                    kern_type   = KERN_TYPE_MD55_PWSLT2;
9305                    dgst_size   = DGST_SIZE_4_4;
9306                    parse_func  = vb30_parse_hash;
9307                    sort_by_digest = sort_by_digest_4_4;
9308                    opti_type   = OPTI_TYPE_ZERO_BYTE
9309                                | OPTI_TYPE_PRECOMPUTE_INIT
9310                                | OPTI_TYPE_EARLY_SKIP;
9311                    dgst_pos0   = 0;
9312                    dgst_pos1   = 3;
9313                    dgst_pos2   = 2;
9314                    dgst_pos3   = 1;
9315                    break;
9316
9317       case  2811:  hash_type   = HASH_TYPE_MD5;
9318                    salt_type   = SALT_TYPE_INTERN;
9319                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9320                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9321                                | OPTS_TYPE_PT_ADD80
9322                                | OPTS_TYPE_PT_ADDBITS14;
9323                    kern_type   = KERN_TYPE_MD55_SLTPW;
9324                    dgst_size   = DGST_SIZE_4_4;
9325                    parse_func  = ipb2_parse_hash;
9326                    sort_by_digest = sort_by_digest_4_4;
9327                    opti_type   = OPTI_TYPE_ZERO_BYTE
9328                                | OPTI_TYPE_PRECOMPUTE_INIT
9329                                | OPTI_TYPE_EARLY_SKIP;
9330                    dgst_pos0   = 0;
9331                    dgst_pos1   = 3;
9332                    dgst_pos2   = 2;
9333                    dgst_pos3   = 1;
9334                    break;
9335
9336       case  3000:  hash_type   = HASH_TYPE_LM;
9337                    salt_type   = SALT_TYPE_NONE;
9338                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9340                                | OPTS_TYPE_PT_UPPER
9341                                | OPTS_TYPE_PT_BITSLICE;
9342                    kern_type   = KERN_TYPE_LM;
9343                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9344                    parse_func  = lm_parse_hash;
9345                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9346                    opti_type   = OPTI_TYPE_ZERO_BYTE
9347                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9348                    dgst_pos0   = 0;
9349                    dgst_pos1   = 1;
9350                    dgst_pos2   = 2;
9351                    dgst_pos3   = 3;
9352                    break;
9353
9354       case  3100:  hash_type   = HASH_TYPE_ORACLEH;
9355                    salt_type   = SALT_TYPE_INTERN;
9356                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9358                                | OPTS_TYPE_PT_UPPER
9359                                | OPTS_TYPE_ST_UPPER;
9360                    kern_type   = KERN_TYPE_ORACLEH;
9361                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9362                    parse_func  = oracleh_parse_hash;
9363                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9364                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9365                    dgst_pos0   = 0;
9366                    dgst_pos1   = 1;
9367                    dgst_pos2   = 2;
9368                    dgst_pos3   = 3;
9369                    break;
9370
9371       case  3200:  hash_type   = HASH_TYPE_BCRYPT;
9372                    salt_type   = SALT_TYPE_EMBEDDED;
9373                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9374                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9375                                | OPTS_TYPE_ST_GENERATE_LE;
9376                    kern_type   = KERN_TYPE_BCRYPT;
9377                    dgst_size   = DGST_SIZE_4_6;
9378                    parse_func  = bcrypt_parse_hash;
9379                    sort_by_digest = sort_by_digest_4_6;
9380                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9381                    dgst_pos0   = 0;
9382                    dgst_pos1   = 1;
9383                    dgst_pos2   = 2;
9384                    dgst_pos3   = 3;
9385                    break;
9386
9387       case  3710:  hash_type   = HASH_TYPE_MD5;
9388                    salt_type   = SALT_TYPE_INTERN;
9389                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9391                                | OPTS_TYPE_PT_ADD80
9392                                | OPTS_TYPE_PT_ADDBITS14;
9393                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9394                    dgst_size   = DGST_SIZE_4_4;
9395                    parse_func  = md5s_parse_hash;
9396                    sort_by_digest = sort_by_digest_4_4;
9397                    opti_type   = OPTI_TYPE_ZERO_BYTE
9398                                | OPTI_TYPE_PRECOMPUTE_INIT
9399                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9400                                | OPTI_TYPE_EARLY_SKIP;
9401                    dgst_pos0   = 0;
9402                    dgst_pos1   = 3;
9403                    dgst_pos2   = 2;
9404                    dgst_pos3   = 1;
9405                    break;
9406
9407       case  3711:  hash_type   = HASH_TYPE_MD5;
9408                    salt_type   = SALT_TYPE_EMBEDDED;
9409                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9410                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9411                                | OPTS_TYPE_PT_ADD80
9412                                | OPTS_TYPE_PT_ADDBITS14;
9413                    kern_type   = KERN_TYPE_MD5_SLT_MD5_PW;
9414                    dgst_size   = DGST_SIZE_4_4;
9415                    parse_func  = mediawiki_b_parse_hash;
9416                    sort_by_digest = sort_by_digest_4_4;
9417                    opti_type   = OPTI_TYPE_ZERO_BYTE
9418                                | OPTI_TYPE_PRECOMPUTE_INIT
9419                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9420                                | OPTI_TYPE_EARLY_SKIP;
9421                    dgst_pos0   = 0;
9422                    dgst_pos1   = 3;
9423                    dgst_pos2   = 2;
9424                    dgst_pos3   = 1;
9425                    break;
9426
9427       case  3800:  hash_type   = HASH_TYPE_MD5;
9428                    salt_type   = SALT_TYPE_INTERN;
9429                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9430                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9431                                | OPTS_TYPE_ST_ADDBITS14;
9432                    kern_type   = KERN_TYPE_MD5_SLT_PW_SLT;
9433                    dgst_size   = DGST_SIZE_4_4;
9434                    parse_func  = md5s_parse_hash;
9435                    sort_by_digest = sort_by_digest_4_4;
9436                    opti_type   = OPTI_TYPE_ZERO_BYTE
9437                                | OPTI_TYPE_PRECOMPUTE_INIT
9438                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9439                                | OPTI_TYPE_EARLY_SKIP
9440                                | OPTI_TYPE_NOT_ITERATED
9441                                | OPTI_TYPE_RAW_HASH;
9442                    dgst_pos0   = 0;
9443                    dgst_pos1   = 3;
9444                    dgst_pos2   = 2;
9445                    dgst_pos3   = 1;
9446                    break;
9447
9448       case  4300:  hash_type   = HASH_TYPE_MD5;
9449                    salt_type   = SALT_TYPE_VIRTUAL;
9450                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9451                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9452                                | OPTS_TYPE_PT_ADD80
9453                                | OPTS_TYPE_PT_ADDBITS14
9454                                | OPTS_TYPE_ST_ADD80;
9455                    kern_type   = KERN_TYPE_MD5U5_PWSLT1;
9456                    dgst_size   = DGST_SIZE_4_4;
9457                    parse_func  = md5md5_parse_hash;
9458                    sort_by_digest = sort_by_digest_4_4;
9459                    opti_type   = OPTI_TYPE_ZERO_BYTE
9460                                | OPTI_TYPE_PRECOMPUTE_INIT
9461                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9462                                | OPTI_TYPE_EARLY_SKIP;
9463                    dgst_pos0   = 0;
9464                    dgst_pos1   = 3;
9465                    dgst_pos2   = 2;
9466                    dgst_pos3   = 1;
9467                    break;
9468
9469
9470       case  4400:  hash_type   = HASH_TYPE_MD5;
9471                    salt_type   = SALT_TYPE_NONE;
9472                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9473                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9474                                | OPTS_TYPE_PT_ADD80
9475                                | OPTS_TYPE_PT_ADDBITS15;
9476                    kern_type   = KERN_TYPE_MD5_SHA1;
9477                    dgst_size   = DGST_SIZE_4_4;
9478                    parse_func  = md5_parse_hash;
9479                    sort_by_digest = sort_by_digest_4_4;
9480                    opti_type   = OPTI_TYPE_ZERO_BYTE
9481                                | OPTI_TYPE_PRECOMPUTE_INIT
9482                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9483                                | OPTI_TYPE_EARLY_SKIP
9484                                | OPTI_TYPE_NOT_ITERATED
9485                                | OPTI_TYPE_NOT_SALTED
9486                                | OPTI_TYPE_RAW_HASH;
9487                    dgst_pos0   = 0;
9488                    dgst_pos1   = 3;
9489                    dgst_pos2   = 2;
9490                    dgst_pos3   = 1;
9491                    break;
9492
9493       case  4500:  hash_type   = HASH_TYPE_SHA1;
9494                    salt_type   = SALT_TYPE_NONE;
9495                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9496                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9497                                | OPTS_TYPE_PT_ADD80
9498                                | OPTS_TYPE_PT_ADDBITS15;
9499                    kern_type   = KERN_TYPE_SHA11;
9500                    dgst_size   = DGST_SIZE_4_5;
9501                    parse_func  = sha1_parse_hash;
9502                    sort_by_digest = sort_by_digest_4_5;
9503                    opti_type   = OPTI_TYPE_ZERO_BYTE
9504                                | OPTI_TYPE_PRECOMPUTE_INIT
9505                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9506                                | OPTI_TYPE_EARLY_SKIP
9507                                | OPTI_TYPE_NOT_SALTED;
9508                    dgst_pos0   = 3;
9509                    dgst_pos1   = 4;
9510                    dgst_pos2   = 2;
9511                    dgst_pos3   = 1;
9512                    break;
9513
9514       case  4700:  hash_type   = HASH_TYPE_SHA1;
9515                    salt_type   = SALT_TYPE_NONE;
9516                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9517                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9518                                | OPTS_TYPE_PT_ADD80
9519                                | OPTS_TYPE_PT_ADDBITS14;
9520                    kern_type   = KERN_TYPE_SHA1_MD5;
9521                    dgst_size   = DGST_SIZE_4_5;
9522                    parse_func  = sha1_parse_hash;
9523                    sort_by_digest = sort_by_digest_4_5;
9524                    opti_type   = OPTI_TYPE_ZERO_BYTE
9525                                | OPTI_TYPE_PRECOMPUTE_INIT
9526                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9527                                | OPTI_TYPE_EARLY_SKIP
9528                                | OPTI_TYPE_NOT_ITERATED
9529                                | OPTI_TYPE_NOT_SALTED
9530                                | OPTI_TYPE_RAW_HASH;
9531                    dgst_pos0   = 3;
9532                    dgst_pos1   = 4;
9533                    dgst_pos2   = 2;
9534                    dgst_pos3   = 1;
9535                    break;
9536
9537       case  4800:  hash_type   = HASH_TYPE_MD5;
9538                    salt_type   = SALT_TYPE_EMBEDDED;
9539                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9540                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9541                                | OPTS_TYPE_PT_ADDBITS14;
9542                    kern_type   = KERN_TYPE_MD5_CHAP;
9543                    dgst_size   = DGST_SIZE_4_4;
9544                    parse_func  = chap_parse_hash;
9545                    sort_by_digest = sort_by_digest_4_4;
9546                    opti_type   = OPTI_TYPE_ZERO_BYTE
9547                                | OPTI_TYPE_PRECOMPUTE_INIT
9548                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9549                                | OPTI_TYPE_MEET_IN_MIDDLE
9550                                | OPTI_TYPE_EARLY_SKIP
9551                                | OPTI_TYPE_NOT_ITERATED
9552                                | OPTI_TYPE_RAW_HASH;
9553                    dgst_pos0   = 0;
9554                    dgst_pos1   = 3;
9555                    dgst_pos2   = 2;
9556                    dgst_pos3   = 1;
9557                    break;
9558
9559       case  4900:  hash_type   = HASH_TYPE_SHA1;
9560                    salt_type   = SALT_TYPE_INTERN;
9561                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9563                    kern_type   = KERN_TYPE_SHA1_SLT_PW_SLT;
9564                    dgst_size   = DGST_SIZE_4_5;
9565                    parse_func  = sha1s_parse_hash;
9566                    sort_by_digest = sort_by_digest_4_5;
9567                    opti_type   = OPTI_TYPE_ZERO_BYTE
9568                                | OPTI_TYPE_PRECOMPUTE_INIT
9569                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9570                                | OPTI_TYPE_EARLY_SKIP;
9571                    dgst_pos0   = 3;
9572                    dgst_pos1   = 4;
9573                    dgst_pos2   = 2;
9574                    dgst_pos3   = 1;
9575                    break;
9576
9577       case  5000:  hash_type   = HASH_TYPE_KECCAK;
9578                    salt_type   = SALT_TYPE_EMBEDDED;
9579                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9581                                | OPTS_TYPE_PT_ADD01;
9582                    kern_type   = KERN_TYPE_KECCAK;
9583                    dgst_size   = DGST_SIZE_8_25;
9584                    parse_func  = keccak_parse_hash;
9585                    sort_by_digest = sort_by_digest_8_25;
9586                    opti_type   = OPTI_TYPE_ZERO_BYTE
9587                                | OPTI_TYPE_USES_BITS_64
9588                                | OPTI_TYPE_RAW_HASH;
9589                    dgst_pos0   = 2;
9590                    dgst_pos1   = 3;
9591                    dgst_pos2   = 4;
9592                    dgst_pos3   = 5;
9593                    break;
9594
9595       case  5100:  hash_type   = HASH_TYPE_MD5H;
9596                    salt_type   = SALT_TYPE_NONE;
9597                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9599                                | OPTS_TYPE_PT_ADD80
9600                                | OPTS_TYPE_PT_ADDBITS14;
9601                    kern_type   = KERN_TYPE_MD5H;
9602                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9603                    parse_func  = md5half_parse_hash;
9604                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9605                    opti_type   = OPTI_TYPE_ZERO_BYTE
9606                                | OPTI_TYPE_RAW_HASH;
9607                    dgst_pos0   = 0;
9608                    dgst_pos1   = 1;
9609                    dgst_pos2   = 2;
9610                    dgst_pos3   = 3;
9611                    break;
9612
9613       case  5200:  hash_type   = HASH_TYPE_SHA256;
9614                    salt_type   = SALT_TYPE_EMBEDDED;
9615                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9616                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9617                    kern_type   = KERN_TYPE_PSAFE3;
9618                    dgst_size   = DGST_SIZE_4_8;
9619                    parse_func  = psafe3_parse_hash;
9620                    sort_by_digest = sort_by_digest_4_8;
9621                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9622                    dgst_pos0   = 0;
9623                    dgst_pos1   = 1;
9624                    dgst_pos2   = 2;
9625                    dgst_pos3   = 3;
9626                    break;
9627
9628       case  5300:  hash_type   = HASH_TYPE_MD5;
9629                    salt_type   = SALT_TYPE_EMBEDDED;
9630                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9632                                | OPTS_TYPE_ST_ADD80;
9633                    kern_type   = KERN_TYPE_IKEPSK_MD5;
9634                    dgst_size   = DGST_SIZE_4_4;
9635                    parse_func  = ikepsk_md5_parse_hash;
9636                    sort_by_digest = sort_by_digest_4_4;
9637                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9638                    dgst_pos0   = 0;
9639                    dgst_pos1   = 3;
9640                    dgst_pos2   = 2;
9641                    dgst_pos3   = 1;
9642                    break;
9643
9644       case  5400:  hash_type   = HASH_TYPE_SHA1;
9645                    salt_type   = SALT_TYPE_EMBEDDED;
9646                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9648                                | OPTS_TYPE_ST_ADD80;
9649                    kern_type   = KERN_TYPE_IKEPSK_SHA1;
9650                    dgst_size   = DGST_SIZE_4_5;
9651                    parse_func  = ikepsk_sha1_parse_hash;
9652                    sort_by_digest = sort_by_digest_4_5;
9653                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9654                    dgst_pos0   = 3;
9655                    dgst_pos1   = 4;
9656                    dgst_pos2   = 2;
9657                    dgst_pos3   = 1;
9658                    break;
9659
9660       case  5500:  hash_type   = HASH_TYPE_NETNTLM;
9661                    salt_type   = SALT_TYPE_EMBEDDED;
9662                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9664                                | OPTS_TYPE_PT_ADD80
9665                                | OPTS_TYPE_PT_ADDBITS14
9666                                | OPTS_TYPE_PT_UNICODE
9667                                | OPTS_TYPE_ST_HEX;
9668                    kern_type   = KERN_TYPE_NETNTLMv1;
9669                    dgst_size   = DGST_SIZE_4_4;
9670                    parse_func  = netntlmv1_parse_hash;
9671                    sort_by_digest = sort_by_digest_4_4;
9672                    opti_type   = OPTI_TYPE_ZERO_BYTE
9673                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
9674                    dgst_pos0   = 0;
9675                    dgst_pos1   = 1;
9676                    dgst_pos2   = 2;
9677                    dgst_pos3   = 3;
9678                    break;
9679
9680       case  5600:  hash_type   = HASH_TYPE_MD5;
9681                    salt_type   = SALT_TYPE_EMBEDDED;
9682                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9683                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9684                                | OPTS_TYPE_PT_ADD80
9685                                | OPTS_TYPE_PT_ADDBITS14
9686                                | OPTS_TYPE_PT_UNICODE;
9687                    kern_type   = KERN_TYPE_NETNTLMv2;
9688                    dgst_size   = DGST_SIZE_4_4;
9689                    parse_func  = netntlmv2_parse_hash;
9690                    sort_by_digest = sort_by_digest_4_4;
9691                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9692                    dgst_pos0   = 0;
9693                    dgst_pos1   = 3;
9694                    dgst_pos2   = 2;
9695                    dgst_pos3   = 1;
9696                    break;
9697
9698       case  5700:  hash_type   = HASH_TYPE_SHA256;
9699                    salt_type   = SALT_TYPE_NONE;
9700                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9701                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9702                                | OPTS_TYPE_PT_ADD80
9703                                | OPTS_TYPE_PT_ADDBITS15;
9704                    kern_type   = KERN_TYPE_SHA256;
9705                    dgst_size   = DGST_SIZE_4_8;
9706                    parse_func  = cisco4_parse_hash;
9707                    sort_by_digest = sort_by_digest_4_8;
9708                    opti_type   = OPTI_TYPE_ZERO_BYTE
9709                                | OPTI_TYPE_PRECOMPUTE_INIT
9710                                | OPTI_TYPE_PRECOMPUTE_MERKLE
9711                                | OPTI_TYPE_EARLY_SKIP
9712                                | OPTI_TYPE_NOT_ITERATED
9713                                | OPTI_TYPE_NOT_SALTED
9714                                | OPTI_TYPE_RAW_HASH;
9715                    dgst_pos0   = 3;
9716                    dgst_pos1   = 7;
9717                    dgst_pos2   = 2;
9718                    dgst_pos3   = 6;
9719                    break;
9720
9721       case  5800:  hash_type   = HASH_TYPE_SHA1;
9722                    salt_type   = SALT_TYPE_INTERN;
9723                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9724                    opts_type   = OPTS_TYPE_PT_GENERATE_LE  // should be OPTS_TYPE_PT_GENERATE_BE
9725                                | OPTS_TYPE_ST_ADD80;
9726                    kern_type   = KERN_TYPE_ANDROIDPIN;
9727                    dgst_size   = DGST_SIZE_4_5;
9728                    parse_func  = androidpin_parse_hash;
9729                    sort_by_digest = sort_by_digest_4_5;
9730                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9731                    dgst_pos0   = 0;
9732                    dgst_pos1   = 1;
9733                    dgst_pos2   = 2;
9734                    dgst_pos3   = 3;
9735                    break;
9736
9737       case  6000:  hash_type   = HASH_TYPE_RIPEMD160;
9738                    salt_type   = SALT_TYPE_NONE;
9739                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
9741                                | OPTS_TYPE_PT_ADD80;
9742                    kern_type   = KERN_TYPE_RIPEMD160;
9743                    dgst_size   = DGST_SIZE_4_5;
9744                    parse_func  = ripemd160_parse_hash;
9745                    sort_by_digest = sort_by_digest_4_5;
9746                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9747                    dgst_pos0   = 0;
9748                    dgst_pos1   = 1;
9749                    dgst_pos2   = 2;
9750                    dgst_pos3   = 3;
9751                    break;
9752
9753       case  6100:  hash_type   = HASH_TYPE_WHIRLPOOL;
9754                    salt_type   = SALT_TYPE_NONE;
9755                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
9757                                | OPTS_TYPE_PT_ADD80;
9758                    kern_type   = KERN_TYPE_WHIRLPOOL;
9759                    dgst_size   = DGST_SIZE_4_16;
9760                    parse_func  = whirlpool_parse_hash;
9761                    sort_by_digest = sort_by_digest_4_16;
9762                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9763                    dgst_pos0   = 0;
9764                    dgst_pos1   = 1;
9765                    dgst_pos2   = 2;
9766                    dgst_pos3   = 3;
9767                    break;
9768
9769       case  6211:  hash_type   = HASH_TYPE_RIPEMD160;
9770                    salt_type   = SALT_TYPE_EMBEDDED;
9771                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9772                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9773                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9774                    dgst_size   = DGST_SIZE_4_5;
9775                    parse_func  = truecrypt_parse_hash_2k;
9776                    sort_by_digest = sort_by_digest_4_5;
9777                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9778                    dgst_pos0   = 0;
9779                    dgst_pos1   = 1;
9780                    dgst_pos2   = 2;
9781                    dgst_pos3   = 3;
9782                    break;
9783
9784       case  6212:  hash_type   = HASH_TYPE_RIPEMD160;
9785                    salt_type   = SALT_TYPE_EMBEDDED;
9786                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9787                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9788                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9789                    dgst_size   = DGST_SIZE_4_5;
9790                    parse_func  = truecrypt_parse_hash_2k;
9791                    sort_by_digest = sort_by_digest_4_5;
9792                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9793                    dgst_pos0   = 0;
9794                    dgst_pos1   = 1;
9795                    dgst_pos2   = 2;
9796                    dgst_pos3   = 3;
9797                    break;
9798
9799       case  6213:  hash_type   = HASH_TYPE_RIPEMD160;
9800                    salt_type   = SALT_TYPE_EMBEDDED;
9801                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9802                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9803                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9804                    dgst_size   = DGST_SIZE_4_5;
9805                    parse_func  = truecrypt_parse_hash_2k;
9806                    sort_by_digest = sort_by_digest_4_5;
9807                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9808                    dgst_pos0   = 0;
9809                    dgst_pos1   = 1;
9810                    dgst_pos2   = 2;
9811                    dgst_pos3   = 3;
9812                    break;
9813
9814       case  6221:  hash_type   = HASH_TYPE_SHA512;
9815                    salt_type   = SALT_TYPE_EMBEDDED;
9816                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9817                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9818                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
9819                    dgst_size   = DGST_SIZE_8_8;
9820                    parse_func  = truecrypt_parse_hash_1k;
9821                    sort_by_digest = sort_by_digest_8_8;
9822                    opti_type   = OPTI_TYPE_ZERO_BYTE
9823                                | OPTI_TYPE_USES_BITS_64;
9824                    dgst_pos0   = 0;
9825                    dgst_pos1   = 1;
9826                    dgst_pos2   = 2;
9827                    dgst_pos3   = 3;
9828                    break;
9829
9830       case  6222:  hash_type   = HASH_TYPE_SHA512;
9831                    salt_type   = SALT_TYPE_EMBEDDED;
9832                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9833                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9834                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
9835                    dgst_size   = DGST_SIZE_8_8;
9836                    parse_func  = truecrypt_parse_hash_1k;
9837                    sort_by_digest = sort_by_digest_8_8;
9838                    opti_type   = OPTI_TYPE_ZERO_BYTE
9839                                | OPTI_TYPE_USES_BITS_64;
9840                    dgst_pos0   = 0;
9841                    dgst_pos1   = 1;
9842                    dgst_pos2   = 2;
9843                    dgst_pos3   = 3;
9844                    break;
9845
9846       case  6223:  hash_type   = HASH_TYPE_SHA512;
9847                    salt_type   = SALT_TYPE_EMBEDDED;
9848                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9849                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9850                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
9851                    dgst_size   = DGST_SIZE_8_8;
9852                    parse_func  = truecrypt_parse_hash_1k;
9853                    sort_by_digest = sort_by_digest_8_8;
9854                    opti_type   = OPTI_TYPE_ZERO_BYTE
9855                                | OPTI_TYPE_USES_BITS_64;
9856                    dgst_pos0   = 0;
9857                    dgst_pos1   = 1;
9858                    dgst_pos2   = 2;
9859                    dgst_pos3   = 3;
9860                    break;
9861
9862       case  6231:  hash_type   = HASH_TYPE_WHIRLPOOL;
9863                    salt_type   = SALT_TYPE_EMBEDDED;
9864                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9865                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9866                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
9867                    dgst_size   = DGST_SIZE_4_8;
9868                    parse_func  = truecrypt_parse_hash_1k;
9869                    sort_by_digest = sort_by_digest_4_8;
9870                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9871                    dgst_pos0   = 0;
9872                    dgst_pos1   = 1;
9873                    dgst_pos2   = 2;
9874                    dgst_pos3   = 3;
9875                    break;
9876
9877       case  6232:  hash_type   = HASH_TYPE_WHIRLPOOL;
9878                    salt_type   = SALT_TYPE_EMBEDDED;
9879                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9880                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9881                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9882                    dgst_size   = DGST_SIZE_4_8;
9883                    parse_func  = truecrypt_parse_hash_1k;
9884                    sort_by_digest = sort_by_digest_4_8;
9885                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9886                    dgst_pos0   = 0;
9887                    dgst_pos1   = 1;
9888                    dgst_pos2   = 2;
9889                    dgst_pos3   = 3;
9890                    break;
9891
9892       case  6233:  hash_type   = HASH_TYPE_WHIRLPOOL;
9893                    salt_type   = SALT_TYPE_EMBEDDED;
9894                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9895                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9896                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9897                    dgst_size   = DGST_SIZE_4_8;
9898                    parse_func  = truecrypt_parse_hash_1k;
9899                    sort_by_digest = sort_by_digest_4_8;
9900                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9901                    dgst_pos0   = 0;
9902                    dgst_pos1   = 1;
9903                    dgst_pos2   = 2;
9904                    dgst_pos3   = 3;
9905                    break;
9906
9907       case  6241:  hash_type   = HASH_TYPE_RIPEMD160;
9908                    salt_type   = SALT_TYPE_EMBEDDED;
9909                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9910                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9911                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
9912                    dgst_size   = DGST_SIZE_4_5;
9913                    parse_func  = truecrypt_parse_hash_1k;
9914                    sort_by_digest = sort_by_digest_4_5;
9915                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9916                    dgst_pos0   = 0;
9917                    dgst_pos1   = 1;
9918                    dgst_pos2   = 2;
9919                    dgst_pos3   = 3;
9920                    break;
9921
9922       case  6242:  hash_type   = HASH_TYPE_RIPEMD160;
9923                    salt_type   = SALT_TYPE_EMBEDDED;
9924                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9925                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9926                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
9927                    dgst_size   = DGST_SIZE_4_5;
9928                    parse_func  = truecrypt_parse_hash_1k;
9929                    sort_by_digest = sort_by_digest_4_5;
9930                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9931                    dgst_pos0   = 0;
9932                    dgst_pos1   = 1;
9933                    dgst_pos2   = 2;
9934                    dgst_pos3   = 3;
9935                    break;
9936
9937       case  6243:  hash_type   = HASH_TYPE_RIPEMD160;
9938                    salt_type   = SALT_TYPE_EMBEDDED;
9939                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9940                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9941                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
9942                    dgst_size   = DGST_SIZE_4_5;
9943                    parse_func  = truecrypt_parse_hash_1k;
9944                    sort_by_digest = sort_by_digest_4_5;
9945                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9946                    dgst_pos0   = 0;
9947                    dgst_pos1   = 1;
9948                    dgst_pos2   = 2;
9949                    dgst_pos3   = 3;
9950                    break;
9951
9952       case  6300:  hash_type   = HASH_TYPE_MD5;
9953                    salt_type   = SALT_TYPE_EMBEDDED;
9954                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
9956                    kern_type   = KERN_TYPE_MD5AIX;
9957                    dgst_size   = DGST_SIZE_4_4;
9958                    parse_func  = md5aix_parse_hash;
9959                    sort_by_digest = sort_by_digest_4_4;
9960                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9961                    dgst_pos0   = 0;
9962                    dgst_pos1   = 1;
9963                    dgst_pos2   = 2;
9964                    dgst_pos3   = 3;
9965                    break;
9966
9967       case  6400:  hash_type   = HASH_TYPE_SHA256;
9968                    salt_type   = SALT_TYPE_EMBEDDED;
9969                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9971                    kern_type   = KERN_TYPE_SHA256AIX;
9972                    dgst_size   = DGST_SIZE_4_8;
9973                    parse_func  = sha256aix_parse_hash;
9974                    sort_by_digest = sort_by_digest_4_8;
9975                    opti_type   = OPTI_TYPE_ZERO_BYTE;
9976                    dgst_pos0   = 0;
9977                    dgst_pos1   = 1;
9978                    dgst_pos2   = 2;
9979                    dgst_pos3   = 3;
9980                    break;
9981
9982       case  6500:  hash_type   = HASH_TYPE_SHA512;
9983                    salt_type   = SALT_TYPE_EMBEDDED;
9984                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9986                    kern_type   = KERN_TYPE_SHA512AIX;
9987                    dgst_size   = DGST_SIZE_8_8;
9988                    parse_func  = sha512aix_parse_hash;
9989                    sort_by_digest = sort_by_digest_8_8;
9990                    opti_type   = OPTI_TYPE_ZERO_BYTE
9991                                | OPTI_TYPE_USES_BITS_64;
9992                    dgst_pos0   = 0;
9993                    dgst_pos1   = 1;
9994                    dgst_pos2   = 2;
9995                    dgst_pos3   = 3;
9996                    break;
9997
9998       case  6600:  hash_type   = HASH_TYPE_AES;
9999                    salt_type   = SALT_TYPE_EMBEDDED;
10000                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10002                    kern_type   = KERN_TYPE_AGILEKEY;
10003                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
10004                    parse_func  = agilekey_parse_hash;
10005                    sort_by_digest = sort_by_digest_4_5;
10006                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10007                    dgst_pos0   = 0;
10008                    dgst_pos1   = 1;
10009                    dgst_pos2   = 2;
10010                    dgst_pos3   = 3;
10011                    break;
10012
10013       case  6700:  hash_type   = HASH_TYPE_SHA1;
10014                    salt_type   = SALT_TYPE_EMBEDDED;
10015                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10017                    kern_type   = KERN_TYPE_SHA1AIX;
10018                    dgst_size   = DGST_SIZE_4_5;
10019                    parse_func  = sha1aix_parse_hash;
10020                    sort_by_digest = sort_by_digest_4_5;
10021                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10022                    dgst_pos0   = 0;
10023                    dgst_pos1   = 1;
10024                    dgst_pos2   = 2;
10025                    dgst_pos3   = 3;
10026                    break;
10027
10028       case  6800:  hash_type   = HASH_TYPE_AES;
10029                    salt_type   = SALT_TYPE_EMBEDDED;
10030                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10032                    kern_type   = KERN_TYPE_LASTPASS;
10033                    dgst_size   = DGST_SIZE_4_8; // because kernel uses _SHA256_
10034                    parse_func  = lastpass_parse_hash;
10035                    sort_by_digest = sort_by_digest_4_8;
10036                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10037                    dgst_pos0   = 0;
10038                    dgst_pos1   = 1;
10039                    dgst_pos2   = 2;
10040                    dgst_pos3   = 3;
10041                    break;
10042
10043       case  6900:  hash_type   = HASH_TYPE_GOST;
10044                    salt_type   = SALT_TYPE_NONE;
10045                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10046                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10047                    kern_type   = KERN_TYPE_GOST;
10048                    dgst_size   = DGST_SIZE_4_8;
10049                    parse_func  = gost_parse_hash;
10050                    sort_by_digest = sort_by_digest_4_8;
10051                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10052                    dgst_pos0   = 0;
10053                    dgst_pos1   = 1;
10054                    dgst_pos2   = 2;
10055                    dgst_pos3   = 3;
10056                    break;
10057
10058       case  7100:  hash_type   = HASH_TYPE_SHA512;
10059                    salt_type   = SALT_TYPE_EMBEDDED;
10060                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10061                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10062                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
10063                    dgst_size   = DGST_SIZE_8_16;
10064                    parse_func  = sha512osx_parse_hash;
10065                    sort_by_digest = sort_by_digest_8_16;
10066                    opti_type   = OPTI_TYPE_ZERO_BYTE
10067                                | OPTI_TYPE_USES_BITS_64
10068                                | OPTI_TYPE_SLOW_HASH_SIMD;
10069                    dgst_pos0   = 0;
10070                    dgst_pos1   = 1;
10071                    dgst_pos2   = 2;
10072                    dgst_pos3   = 3;
10073                    break;
10074
10075       case  7200:  hash_type   = HASH_TYPE_SHA512;
10076                    salt_type   = SALT_TYPE_EMBEDDED;
10077                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10078                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10079                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
10080                    dgst_size   = DGST_SIZE_8_16;
10081                    parse_func  = sha512grub_parse_hash;
10082                    sort_by_digest = sort_by_digest_8_16;
10083                    opti_type   = OPTI_TYPE_ZERO_BYTE
10084                                | OPTI_TYPE_USES_BITS_64
10085                                | OPTI_TYPE_SLOW_HASH_SIMD;
10086                    dgst_pos0   = 0;
10087                    dgst_pos1   = 1;
10088                    dgst_pos2   = 2;
10089                    dgst_pos3   = 3;
10090                    break;
10091
10092       case  7300:  hash_type   = HASH_TYPE_SHA1;
10093                    salt_type   = SALT_TYPE_EMBEDDED;
10094                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10095                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10096                                | OPTS_TYPE_ST_ADD80
10097                                | OPTS_TYPE_ST_ADDBITS15;
10098                    kern_type   = KERN_TYPE_RAKP;
10099                    dgst_size   = DGST_SIZE_4_5;
10100                    parse_func  = rakp_parse_hash;
10101                    sort_by_digest = sort_by_digest_4_5;
10102                    opti_type   = OPTI_TYPE_ZERO_BYTE
10103                                | OPTI_TYPE_NOT_ITERATED;
10104                    dgst_pos0   = 3;
10105                    dgst_pos1   = 4;
10106                    dgst_pos2   = 2;
10107                    dgst_pos3   = 1;
10108                    break;
10109
10110       case  7400:  hash_type   = HASH_TYPE_SHA256;
10111                    salt_type   = SALT_TYPE_EMBEDDED;
10112                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10114                    kern_type   = KERN_TYPE_SHA256CRYPT;
10115                    dgst_size   = DGST_SIZE_4_8;
10116                    parse_func  = sha256crypt_parse_hash;
10117                    sort_by_digest = sort_by_digest_4_8;
10118                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10119                    dgst_pos0   = 0;
10120                    dgst_pos1   = 1;
10121                    dgst_pos2   = 2;
10122                    dgst_pos3   = 3;
10123                    break;
10124
10125       case  7500:  hash_type   = HASH_TYPE_KRB5PA;
10126                    salt_type   = SALT_TYPE_EMBEDDED;
10127                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10129                    kern_type   = KERN_TYPE_KRB5PA;
10130                    dgst_size   = DGST_SIZE_4_4;
10131                    parse_func  = krb5pa_parse_hash;
10132                    sort_by_digest = sort_by_digest_4_4;
10133                    opti_type   = OPTI_TYPE_ZERO_BYTE
10134                                | OPTI_TYPE_NOT_ITERATED;
10135                    dgst_pos0   = 0;
10136                    dgst_pos1   = 1;
10137                    dgst_pos2   = 2;
10138                    dgst_pos3   = 3;
10139                    break;
10140
10141       case  7600:  hash_type   = HASH_TYPE_SHA1;
10142                    salt_type   = SALT_TYPE_INTERN;
10143                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10144                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10145                                | OPTS_TYPE_PT_ADD80
10146                                | OPTS_TYPE_PT_ADDBITS15;
10147                    kern_type   = KERN_TYPE_SHA1_SLT_SHA1_PW;
10148                    dgst_size   = DGST_SIZE_4_5;
10149                    parse_func  = redmine_parse_hash;
10150                    sort_by_digest = sort_by_digest_4_5;
10151                    opti_type   = OPTI_TYPE_ZERO_BYTE
10152                                | OPTI_TYPE_PRECOMPUTE_INIT
10153                                | OPTI_TYPE_EARLY_SKIP
10154                                | OPTI_TYPE_NOT_ITERATED
10155                                | OPTI_TYPE_PREPENDED_SALT;
10156                    dgst_pos0   = 3;
10157                    dgst_pos1   = 4;
10158                    dgst_pos2   = 2;
10159                    dgst_pos3   = 1;
10160                    break;
10161
10162       case  7700:  hash_type   = HASH_TYPE_SAPB;
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_UPPER
10167                                | OPTS_TYPE_ST_UPPER;
10168                    kern_type   = KERN_TYPE_SAPB;
10169                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10170                    parse_func  = sapb_parse_hash;
10171                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10172                    opti_type   = OPTI_TYPE_ZERO_BYTE
10173                                | OPTI_TYPE_PRECOMPUTE_INIT
10174                                | OPTI_TYPE_NOT_ITERATED;
10175                    dgst_pos0   = 0;
10176                    dgst_pos1   = 1;
10177                    dgst_pos2   = 2;
10178                    dgst_pos3   = 3;
10179                    break;
10180
10181       case  7800:  hash_type   = HASH_TYPE_SAPG;
10182                    salt_type   = SALT_TYPE_EMBEDDED;
10183                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10184                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10185                                | OPTS_TYPE_ST_ADD80
10186                                | OPTS_TYPE_ST_UPPER;
10187                    kern_type   = KERN_TYPE_SAPG;
10188                    dgst_size   = DGST_SIZE_4_5;
10189                    parse_func  = sapg_parse_hash;
10190                    sort_by_digest = sort_by_digest_4_5;
10191                    opti_type   = OPTI_TYPE_ZERO_BYTE
10192                                | OPTI_TYPE_PRECOMPUTE_INIT
10193                                | OPTI_TYPE_NOT_ITERATED;
10194                    dgst_pos0   = 3;
10195                    dgst_pos1   = 4;
10196                    dgst_pos2   = 2;
10197                    dgst_pos3   = 1;
10198                    break;
10199
10200       case  7900:  hash_type   = HASH_TYPE_SHA512;
10201                    salt_type   = SALT_TYPE_EMBEDDED;
10202                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10204                    kern_type   = KERN_TYPE_DRUPAL7;
10205                    dgst_size   = DGST_SIZE_8_8;
10206                    parse_func  = drupal7_parse_hash;
10207                    sort_by_digest = sort_by_digest_8_8;
10208                    opti_type   = OPTI_TYPE_ZERO_BYTE
10209                                | OPTI_TYPE_USES_BITS_64;
10210                    dgst_pos0   = 0;
10211                    dgst_pos1   = 1;
10212                    dgst_pos2   = 2;
10213                    dgst_pos3   = 3;
10214                    break;
10215
10216       case  8000:  hash_type   = HASH_TYPE_SHA256;
10217                    salt_type   = SALT_TYPE_EMBEDDED;
10218                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10219                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10220                                | OPTS_TYPE_PT_UNICODE
10221                                | OPTS_TYPE_ST_ADD80
10222                                | OPTS_TYPE_ST_HEX;
10223                    kern_type   = KERN_TYPE_SYBASEASE;
10224                    dgst_size   = DGST_SIZE_4_8;
10225                    parse_func  = sybasease_parse_hash;
10226                    sort_by_digest = sort_by_digest_4_8;
10227                    opti_type   = OPTI_TYPE_ZERO_BYTE
10228                                | OPTI_TYPE_PRECOMPUTE_INIT
10229                                | OPTI_TYPE_EARLY_SKIP
10230                                | OPTI_TYPE_NOT_ITERATED
10231                                | OPTI_TYPE_RAW_HASH;
10232                    dgst_pos0   = 3;
10233                    dgst_pos1   = 7;
10234                    dgst_pos2   = 2;
10235                    dgst_pos3   = 6;
10236                    break;
10237
10238       case  8100:  hash_type   = HASH_TYPE_SHA1;
10239                    salt_type   = SALT_TYPE_EMBEDDED;
10240                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10241                    opts_type   = OPTS_TYPE_PT_GENERATE_BE;
10242                    kern_type   = KERN_TYPE_NETSCALER;
10243                    dgst_size   = DGST_SIZE_4_5;
10244                    parse_func  = netscaler_parse_hash;
10245                    sort_by_digest = sort_by_digest_4_5;
10246                    opti_type   = OPTI_TYPE_ZERO_BYTE
10247                                | OPTI_TYPE_PRECOMPUTE_INIT
10248                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10249                                | OPTI_TYPE_EARLY_SKIP
10250                                | OPTI_TYPE_NOT_ITERATED
10251                                | OPTI_TYPE_PREPENDED_SALT
10252                                | OPTI_TYPE_RAW_HASH;
10253                    dgst_pos0   = 3;
10254                    dgst_pos1   = 4;
10255                    dgst_pos2   = 2;
10256                    dgst_pos3   = 1;
10257                    break;
10258
10259       case  8200:  hash_type   = HASH_TYPE_SHA256;
10260                    salt_type   = SALT_TYPE_EMBEDDED;
10261                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10262                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10263                    kern_type   = KERN_TYPE_CLOUDKEY;
10264                    dgst_size   = DGST_SIZE_4_8;
10265                    parse_func  = cloudkey_parse_hash;
10266                    sort_by_digest = sort_by_digest_4_8;
10267                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10268                    dgst_pos0   = 0;
10269                    dgst_pos1   = 1;
10270                    dgst_pos2   = 2;
10271                    dgst_pos3   = 3;
10272                    break;
10273
10274       case  8300:  hash_type   = HASH_TYPE_SHA1;
10275                    salt_type   = SALT_TYPE_EMBEDDED;
10276                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10277                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10278                                | OPTS_TYPE_ST_HEX
10279                                | OPTS_TYPE_ST_ADD80;
10280                    kern_type   = KERN_TYPE_NSEC3;
10281                    dgst_size   = DGST_SIZE_4_5;
10282                    parse_func  = nsec3_parse_hash;
10283                    sort_by_digest = sort_by_digest_4_5;
10284                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10285                    dgst_pos0   = 3;
10286                    dgst_pos1   = 4;
10287                    dgst_pos2   = 2;
10288                    dgst_pos3   = 1;
10289                    break;
10290
10291       case  8400:  hash_type   = HASH_TYPE_SHA1;
10292                    salt_type   = SALT_TYPE_INTERN;
10293                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10294                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10295                                | OPTS_TYPE_PT_ADD80
10296                                | OPTS_TYPE_PT_ADDBITS15;
10297                    kern_type   = KERN_TYPE_WBB3;
10298                    dgst_size   = DGST_SIZE_4_5;
10299                    parse_func  = wbb3_parse_hash;
10300                    sort_by_digest = sort_by_digest_4_5;
10301                    opti_type   = OPTI_TYPE_ZERO_BYTE
10302                                | OPTI_TYPE_PRECOMPUTE_INIT
10303                                | OPTI_TYPE_NOT_ITERATED;
10304                    dgst_pos0   = 3;
10305                    dgst_pos1   = 4;
10306                    dgst_pos2   = 2;
10307                    dgst_pos3   = 1;
10308                    break;
10309
10310       case  8500:  hash_type   = HASH_TYPE_DESRACF;
10311                    salt_type   = SALT_TYPE_EMBEDDED;
10312                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10313                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10314                                | OPTS_TYPE_ST_UPPER;
10315                    kern_type   = KERN_TYPE_RACF;
10316                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10317                    parse_func  = racf_parse_hash;
10318                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10319                    opti_type   = OPTI_TYPE_ZERO_BYTE
10320                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
10321                    dgst_pos0   = 0;
10322                    dgst_pos1   = 1;
10323                    dgst_pos2   = 2;
10324                    dgst_pos3   = 3;
10325                    break;
10326
10327       case  8600:  hash_type   = HASH_TYPE_LOTUS5;
10328                    salt_type   = SALT_TYPE_NONE;
10329                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10330                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10331                    kern_type   = KERN_TYPE_LOTUS5;
10332                    dgst_size   = DGST_SIZE_4_4;
10333                    parse_func  = lotus5_parse_hash;
10334                    sort_by_digest = sort_by_digest_4_4;
10335                    opti_type   = OPTI_TYPE_EARLY_SKIP
10336                                | OPTI_TYPE_NOT_ITERATED
10337                                | OPTI_TYPE_NOT_SALTED
10338                                | OPTI_TYPE_RAW_HASH;
10339                    dgst_pos0   = 0;
10340                    dgst_pos1   = 1;
10341                    dgst_pos2   = 2;
10342                    dgst_pos3   = 3;
10343                    break;
10344
10345       case  8700:  hash_type   = HASH_TYPE_LOTUS6;
10346                    salt_type   = SALT_TYPE_EMBEDDED;
10347                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10348                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10349                    kern_type   = KERN_TYPE_LOTUS6;
10350                    dgst_size   = DGST_SIZE_4_4;
10351                    parse_func  = lotus6_parse_hash;
10352                    sort_by_digest = sort_by_digest_4_4;
10353                    opti_type   = OPTI_TYPE_EARLY_SKIP
10354                                | OPTI_TYPE_NOT_ITERATED
10355                                | OPTI_TYPE_RAW_HASH;
10356                    dgst_pos0   = 0;
10357                    dgst_pos1   = 1;
10358                    dgst_pos2   = 2;
10359                    dgst_pos3   = 3;
10360                    break;
10361
10362       case  8800:  hash_type   = HASH_TYPE_ANDROIDFDE;
10363                    salt_type   = SALT_TYPE_EMBEDDED;
10364                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10365                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10366                    kern_type   = KERN_TYPE_ANDROIDFDE;
10367                    dgst_size   = DGST_SIZE_4_4;
10368                    parse_func  = androidfde_parse_hash;
10369                    sort_by_digest = sort_by_digest_4_4;
10370                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10371                    dgst_pos0   = 0;
10372                    dgst_pos1   = 1;
10373                    dgst_pos2   = 2;
10374                    dgst_pos3   = 3;
10375                    break;
10376
10377       case  8900:  hash_type   = HASH_TYPE_SCRYPT;
10378                    salt_type   = SALT_TYPE_EMBEDDED;
10379                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10381                    kern_type   = KERN_TYPE_SCRYPT;
10382                    dgst_size   = DGST_SIZE_4_8;
10383                    parse_func  = scrypt_parse_hash;
10384                    sort_by_digest = sort_by_digest_4_8;
10385                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10386                    dgst_pos0   = 0;
10387                    dgst_pos1   = 1;
10388                    dgst_pos2   = 2;
10389                    dgst_pos3   = 3;
10390                    break;
10391
10392       case  9000:  hash_type   = HASH_TYPE_SHA1;
10393                    salt_type   = SALT_TYPE_EMBEDDED;
10394                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10395                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10396                                | OPTS_TYPE_ST_GENERATE_LE;
10397                    kern_type   = KERN_TYPE_PSAFE2;
10398                    dgst_size   = DGST_SIZE_4_5;
10399                    parse_func  = psafe2_parse_hash;
10400                    sort_by_digest = sort_by_digest_4_5;
10401                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10402                    dgst_pos0   = 0;
10403                    dgst_pos1   = 1;
10404                    dgst_pos2   = 2;
10405                    dgst_pos3   = 3;
10406                    break;
10407
10408       case  9100:  hash_type   = HASH_TYPE_LOTUS8;
10409                    salt_type   = SALT_TYPE_EMBEDDED;
10410                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10411                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10412                    kern_type   = KERN_TYPE_LOTUS8;
10413                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10414                    parse_func  = lotus8_parse_hash;
10415                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10416                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10417                    dgst_pos0   = 0;
10418                    dgst_pos1   = 1;
10419                    dgst_pos2   = 2;
10420                    dgst_pos3   = 3;
10421                    break;
10422
10423       case  9200:  hash_type   = HASH_TYPE_SHA256;
10424                    salt_type   = SALT_TYPE_EMBEDDED;
10425                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10426                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10427                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10428                    dgst_size   = DGST_SIZE_4_32;
10429                    parse_func  = cisco8_parse_hash;
10430                    sort_by_digest = sort_by_digest_4_32;
10431                    opti_type   = OPTI_TYPE_ZERO_BYTE
10432                                | OPTI_TYPE_SLOW_HASH_SIMD;
10433                    dgst_pos0   = 0;
10434                    dgst_pos1   = 1;
10435                    dgst_pos2   = 2;
10436                    dgst_pos3   = 3;
10437                    break;
10438
10439       case  9300:  hash_type   = HASH_TYPE_SCRYPT;
10440                    salt_type   = SALT_TYPE_EMBEDDED;
10441                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10442                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10443                    kern_type   = KERN_TYPE_SCRYPT;
10444                    dgst_size   = DGST_SIZE_4_8;
10445                    parse_func  = cisco9_parse_hash;
10446                    sort_by_digest = sort_by_digest_4_8;
10447                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10448                    dgst_pos0   = 0;
10449                    dgst_pos1   = 1;
10450                    dgst_pos2   = 2;
10451                    dgst_pos3   = 3;
10452                    break;
10453
10454       case  9400:  hash_type   = HASH_TYPE_OFFICE2007;
10455                    salt_type   = SALT_TYPE_EMBEDDED;
10456                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10457                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10458                    kern_type   = KERN_TYPE_OFFICE2007;
10459                    dgst_size   = DGST_SIZE_4_4;
10460                    parse_func  = office2007_parse_hash;
10461                    sort_by_digest = sort_by_digest_4_4;
10462                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10463                    dgst_pos0   = 0;
10464                    dgst_pos1   = 1;
10465                    dgst_pos2   = 2;
10466                    dgst_pos3   = 3;
10467                    break;
10468
10469       case  9500:  hash_type   = HASH_TYPE_OFFICE2010;
10470                    salt_type   = SALT_TYPE_EMBEDDED;
10471                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10473                    kern_type   = KERN_TYPE_OFFICE2010;
10474                    dgst_size   = DGST_SIZE_4_4;
10475                    parse_func  = office2010_parse_hash;
10476                    sort_by_digest = sort_by_digest_4_4;
10477                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10478                    dgst_pos0   = 0;
10479                    dgst_pos1   = 1;
10480                    dgst_pos2   = 2;
10481                    dgst_pos3   = 3;
10482                    break;
10483
10484       case  9600:  hash_type   = HASH_TYPE_OFFICE2013;
10485                    salt_type   = SALT_TYPE_EMBEDDED;
10486                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10488                    kern_type   = KERN_TYPE_OFFICE2013;
10489                    dgst_size   = DGST_SIZE_4_4;
10490                    parse_func  = office2013_parse_hash;
10491                    sort_by_digest = sort_by_digest_4_4;
10492                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10493                    dgst_pos0   = 0;
10494                    dgst_pos1   = 1;
10495                    dgst_pos2   = 2;
10496                    dgst_pos3   = 3;
10497                    break;
10498
10499       case  9700:  hash_type   = HASH_TYPE_OLDOFFICE01;
10500                    salt_type   = SALT_TYPE_EMBEDDED;
10501                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10502                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10503                                | OPTS_TYPE_PT_ADD80
10504                                | OPTS_TYPE_PT_UNICODE;
10505                    kern_type   = KERN_TYPE_OLDOFFICE01;
10506                    dgst_size   = DGST_SIZE_4_4;
10507                    parse_func  = oldoffice01_parse_hash;
10508                    sort_by_digest = sort_by_digest_4_4;
10509                    opti_type   = OPTI_TYPE_ZERO_BYTE
10510                                | OPTI_TYPE_PRECOMPUTE_INIT
10511                                | OPTI_TYPE_NOT_ITERATED;
10512                    dgst_pos0   = 0;
10513                    dgst_pos1   = 1;
10514                    dgst_pos2   = 2;
10515                    dgst_pos3   = 3;
10516                    break;
10517
10518       case  9710:  hash_type   = HASH_TYPE_OLDOFFICE01;
10519                    salt_type   = SALT_TYPE_EMBEDDED;
10520                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10521                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10522                                | OPTS_TYPE_PT_ADD80;
10523                    kern_type   = KERN_TYPE_OLDOFFICE01CM1;
10524                    dgst_size   = DGST_SIZE_4_4;
10525                    parse_func  = oldoffice01cm1_parse_hash;
10526                    sort_by_digest = sort_by_digest_4_4;
10527                    opti_type   = OPTI_TYPE_ZERO_BYTE
10528                                | OPTI_TYPE_PRECOMPUTE_INIT
10529                                | OPTI_TYPE_NOT_ITERATED;
10530                    dgst_pos0   = 0;
10531                    dgst_pos1   = 1;
10532                    dgst_pos2   = 2;
10533                    dgst_pos3   = 3;
10534                    break;
10535
10536       case  9720:  hash_type   = HASH_TYPE_OLDOFFICE01;
10537                    salt_type   = SALT_TYPE_EMBEDDED;
10538                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10539                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10540                                | OPTS_TYPE_PT_ADD80
10541                                | OPTS_TYPE_PT_UNICODE
10542                                | OPTS_TYPE_PT_NEVERCRACK;
10543                    kern_type   = KERN_TYPE_OLDOFFICE01CM2;
10544                    dgst_size   = DGST_SIZE_4_4;
10545                    parse_func  = oldoffice01cm2_parse_hash;
10546                    sort_by_digest = sort_by_digest_4_4;
10547                    opti_type   = OPTI_TYPE_ZERO_BYTE
10548                                | OPTI_TYPE_PRECOMPUTE_INIT
10549                                | OPTI_TYPE_NOT_ITERATED;
10550                    dgst_pos0   = 0;
10551                    dgst_pos1   = 1;
10552                    dgst_pos2   = 2;
10553                    dgst_pos3   = 3;
10554                    break;
10555
10556       case  9800:  hash_type   = HASH_TYPE_OLDOFFICE34;
10557                    salt_type   = SALT_TYPE_EMBEDDED;
10558                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10559                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10560                                | OPTS_TYPE_PT_ADD80
10561                                | OPTS_TYPE_PT_UNICODE;
10562                    kern_type   = KERN_TYPE_OLDOFFICE34;
10563                    dgst_size   = DGST_SIZE_4_4;
10564                    parse_func  = oldoffice34_parse_hash;
10565                    sort_by_digest = sort_by_digest_4_4;
10566                    opti_type   = OPTI_TYPE_ZERO_BYTE
10567                                | OPTI_TYPE_PRECOMPUTE_INIT
10568                                | OPTI_TYPE_NOT_ITERATED;
10569                    dgst_pos0   = 0;
10570                    dgst_pos1   = 1;
10571                    dgst_pos2   = 2;
10572                    dgst_pos3   = 3;
10573                    break;
10574
10575       case  9810:  hash_type   = HASH_TYPE_OLDOFFICE34;
10576                    salt_type   = SALT_TYPE_EMBEDDED;
10577                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10578                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10579                    kern_type   = KERN_TYPE_OLDOFFICE34CM1;
10580                    dgst_size   = DGST_SIZE_4_4;
10581                    parse_func  = oldoffice34cm1_parse_hash;
10582                    sort_by_digest = sort_by_digest_4_4;
10583                    opti_type   = OPTI_TYPE_ZERO_BYTE
10584                                | OPTI_TYPE_PRECOMPUTE_INIT
10585                                | OPTI_TYPE_NOT_ITERATED;
10586                    dgst_pos0   = 0;
10587                    dgst_pos1   = 1;
10588                    dgst_pos2   = 2;
10589                    dgst_pos3   = 3;
10590                    break;
10591
10592       case  9820:  hash_type   = HASH_TYPE_OLDOFFICE34;
10593                    salt_type   = SALT_TYPE_EMBEDDED;
10594                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10595                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10596                                | OPTS_TYPE_PT_ADD80
10597                                | OPTS_TYPE_PT_UNICODE
10598                                | OPTS_TYPE_PT_NEVERCRACK;
10599                    kern_type   = KERN_TYPE_OLDOFFICE34CM2;
10600                    dgst_size   = DGST_SIZE_4_4;
10601                    parse_func  = oldoffice34cm2_parse_hash;
10602                    sort_by_digest = sort_by_digest_4_4;
10603                    opti_type   = OPTI_TYPE_ZERO_BYTE
10604                                | OPTI_TYPE_PRECOMPUTE_INIT
10605                                | OPTI_TYPE_NOT_ITERATED;
10606                    dgst_pos0   = 0;
10607                    dgst_pos1   = 1;
10608                    dgst_pos2   = 2;
10609                    dgst_pos3   = 3;
10610                    break;
10611
10612       case  9900:  hash_type   = HASH_TYPE_MD5;
10613                    salt_type   = SALT_TYPE_NONE;
10614                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10615                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10616                    kern_type   = KERN_TYPE_RADMIN2;
10617                    dgst_size   = DGST_SIZE_4_4;
10618                    parse_func  = radmin2_parse_hash;
10619                    sort_by_digest = sort_by_digest_4_4;
10620                    opti_type   = OPTI_TYPE_ZERO_BYTE
10621                                | OPTI_TYPE_PRECOMPUTE_INIT
10622                                | OPTI_TYPE_EARLY_SKIP
10623                                | OPTI_TYPE_NOT_ITERATED
10624                                | OPTI_TYPE_NOT_SALTED;
10625                    dgst_pos0   = 0;
10626                    dgst_pos1   = 3;
10627                    dgst_pos2   = 2;
10628                    dgst_pos3   = 1;
10629                    break;
10630
10631       case 10000:  hash_type   = HASH_TYPE_SHA256;
10632                    salt_type   = SALT_TYPE_EMBEDDED;
10633                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10634                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10635                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10636                    dgst_size   = DGST_SIZE_4_32;
10637                    parse_func  = djangopbkdf2_parse_hash;
10638                    sort_by_digest = sort_by_digest_4_32;
10639                    opti_type   = OPTI_TYPE_ZERO_BYTE
10640                                | OPTI_TYPE_SLOW_HASH_SIMD;
10641                    dgst_pos0   = 0;
10642                    dgst_pos1   = 1;
10643                    dgst_pos2   = 2;
10644                    dgst_pos3   = 3;
10645                    break;
10646
10647       case 10100:  hash_type   = HASH_TYPE_SIPHASH;
10648                    salt_type   = SALT_TYPE_EMBEDDED;
10649                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10650                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10651                    kern_type   = KERN_TYPE_SIPHASH;
10652                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10653                    parse_func  = siphash_parse_hash;
10654                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10655                    opti_type   = OPTI_TYPE_ZERO_BYTE
10656                                | OPTI_TYPE_NOT_ITERATED
10657                                | OPTI_TYPE_RAW_HASH;
10658                    dgst_pos0   = 0;
10659                    dgst_pos1   = 1;
10660                    dgst_pos2   = 2;
10661                    dgst_pos3   = 3;
10662                    break;
10663
10664       case 10200:  hash_type   = HASH_TYPE_MD5;
10665                    salt_type   = SALT_TYPE_EMBEDDED;
10666                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10667                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10668                                | OPTS_TYPE_ST_ADD80
10669                                | OPTS_TYPE_ST_ADDBITS14;
10670                    kern_type   = KERN_TYPE_HMACMD5_PW;
10671                    dgst_size   = DGST_SIZE_4_4;
10672                    parse_func  = crammd5_parse_hash;
10673                    sort_by_digest = sort_by_digest_4_4;
10674                    opti_type   = OPTI_TYPE_ZERO_BYTE
10675                                | OPTI_TYPE_NOT_ITERATED;
10676                    dgst_pos0   = 0;
10677                    dgst_pos1   = 3;
10678                    dgst_pos2   = 2;
10679                    dgst_pos3   = 1;
10680                    break;
10681
10682       case 10300:  hash_type   = HASH_TYPE_SHA1;
10683                    salt_type   = SALT_TYPE_EMBEDDED;
10684                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10686                    kern_type   = KERN_TYPE_SAPH_SHA1;
10687                    dgst_size   = DGST_SIZE_4_5;
10688                    parse_func  = saph_sha1_parse_hash;
10689                    sort_by_digest = sort_by_digest_4_5;
10690                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10691                    dgst_pos0   = 0;
10692                    dgst_pos1   = 1;
10693                    dgst_pos2   = 2;
10694                    dgst_pos3   = 3;
10695                    break;
10696
10697       case 10400:  hash_type   = HASH_TYPE_PDFU16;
10698                    salt_type   = SALT_TYPE_EMBEDDED;
10699                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10700                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10701                    kern_type   = KERN_TYPE_PDF11;
10702                    dgst_size   = DGST_SIZE_4_4;
10703                    parse_func  = pdf11_parse_hash;
10704                    sort_by_digest = sort_by_digest_4_4;
10705                    opti_type   = OPTI_TYPE_ZERO_BYTE
10706                                | OPTI_TYPE_NOT_ITERATED;
10707                    dgst_pos0   = 0;
10708                    dgst_pos1   = 1;
10709                    dgst_pos2   = 2;
10710                    dgst_pos3   = 3;
10711                    break;
10712
10713       case 10410:  hash_type   = HASH_TYPE_PDFU16;
10714                    salt_type   = SALT_TYPE_EMBEDDED;
10715                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10716                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10717                    kern_type   = KERN_TYPE_PDF11CM1;
10718                    dgst_size   = DGST_SIZE_4_4;
10719                    parse_func  = pdf11cm1_parse_hash;
10720                    sort_by_digest = sort_by_digest_4_4;
10721                    opti_type   = OPTI_TYPE_ZERO_BYTE
10722                                | OPTI_TYPE_NOT_ITERATED;
10723                    dgst_pos0   = 0;
10724                    dgst_pos1   = 1;
10725                    dgst_pos2   = 2;
10726                    dgst_pos3   = 3;
10727                    break;
10728
10729       case 10420:  hash_type   = HASH_TYPE_PDFU16;
10730                    salt_type   = SALT_TYPE_EMBEDDED;
10731                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10732                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10733                    kern_type   = KERN_TYPE_PDF11CM2;
10734                    dgst_size   = DGST_SIZE_4_4;
10735                    parse_func  = pdf11cm2_parse_hash;
10736                    sort_by_digest = sort_by_digest_4_4;
10737                    opti_type   = OPTI_TYPE_ZERO_BYTE
10738                                | OPTI_TYPE_NOT_ITERATED;
10739                    dgst_pos0   = 0;
10740                    dgst_pos1   = 1;
10741                    dgst_pos2   = 2;
10742                    dgst_pos3   = 3;
10743                    break;
10744
10745       case 10500:  hash_type   = HASH_TYPE_PDFU16;
10746                    salt_type   = SALT_TYPE_EMBEDDED;
10747                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10748                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
10749                    kern_type   = KERN_TYPE_PDF14;
10750                    dgst_size   = DGST_SIZE_4_4;
10751                    parse_func  = pdf14_parse_hash;
10752                    sort_by_digest = sort_by_digest_4_4;
10753                    opti_type   = OPTI_TYPE_ZERO_BYTE
10754                                | OPTI_TYPE_NOT_ITERATED;
10755                    dgst_pos0   = 0;
10756                    dgst_pos1   = 1;
10757                    dgst_pos2   = 2;
10758                    dgst_pos3   = 3;
10759                    break;
10760
10761       case 10600:  hash_type   = HASH_TYPE_SHA256;
10762                    salt_type   = SALT_TYPE_EMBEDDED;
10763                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10764                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10765                                | OPTS_TYPE_ST_ADD80
10766                                | OPTS_TYPE_ST_ADDBITS15
10767                                | OPTS_TYPE_HASH_COPY;
10768                    kern_type   = KERN_TYPE_SHA256_PWSLT;
10769                    dgst_size   = DGST_SIZE_4_8;
10770                    parse_func  = pdf17l3_parse_hash;
10771                    sort_by_digest = sort_by_digest_4_8;
10772                    opti_type   = OPTI_TYPE_ZERO_BYTE
10773                                | OPTI_TYPE_PRECOMPUTE_INIT
10774                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10775                                | OPTI_TYPE_EARLY_SKIP
10776                                | OPTI_TYPE_NOT_ITERATED
10777                                | OPTI_TYPE_APPENDED_SALT
10778                                | OPTI_TYPE_RAW_HASH;
10779                    dgst_pos0   = 3;
10780                    dgst_pos1   = 7;
10781                    dgst_pos2   = 2;
10782                    dgst_pos3   = 6;
10783                    break;
10784
10785       case 10700:  hash_type   = HASH_TYPE_PDFU32;
10786                    salt_type   = SALT_TYPE_EMBEDDED;
10787                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10788                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10789                                | OPTS_TYPE_HASH_COPY;
10790                    kern_type   = KERN_TYPE_PDF17L8;
10791                    dgst_size   = DGST_SIZE_4_8;
10792                    parse_func  = pdf17l8_parse_hash;
10793                    sort_by_digest = sort_by_digest_4_8;
10794                    opti_type   = OPTI_TYPE_ZERO_BYTE
10795                                | OPTI_TYPE_NOT_ITERATED;
10796                    dgst_pos0   = 0;
10797                    dgst_pos1   = 1;
10798                    dgst_pos2   = 2;
10799                    dgst_pos3   = 3;
10800                    break;
10801
10802       case 10800:  hash_type   = HASH_TYPE_SHA384;
10803                    salt_type   = SALT_TYPE_NONE;
10804                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10805                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10806                                | OPTS_TYPE_PT_ADD80
10807                                | OPTS_TYPE_PT_ADDBITS15;
10808                    kern_type   = KERN_TYPE_SHA384;
10809                    dgst_size   = DGST_SIZE_8_8;
10810                    parse_func  = sha384_parse_hash;
10811                    sort_by_digest = sort_by_digest_8_8;
10812                    opti_type   = OPTI_TYPE_ZERO_BYTE
10813                                | OPTI_TYPE_PRECOMPUTE_INIT
10814                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10815                                | OPTI_TYPE_EARLY_SKIP
10816                                | OPTI_TYPE_NOT_ITERATED
10817                                | OPTI_TYPE_NOT_SALTED
10818                                | OPTI_TYPE_USES_BITS_64
10819                                | OPTI_TYPE_RAW_HASH;
10820                    dgst_pos0   = 6;
10821                    dgst_pos1   = 7;
10822                    dgst_pos2   = 4;
10823                    dgst_pos3   = 5;
10824                    break;
10825
10826       case 10900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
10827                    salt_type   = SALT_TYPE_EMBEDDED;
10828                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10829                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10830                                | OPTS_TYPE_ST_BASE64
10831                                | OPTS_TYPE_HASH_COPY;
10832                    kern_type   = KERN_TYPE_PBKDF2_SHA256;
10833                    dgst_size   = DGST_SIZE_4_32;
10834                    parse_func  = pbkdf2_sha256_parse_hash;
10835                    sort_by_digest = sort_by_digest_4_32;
10836                    opti_type   = OPTI_TYPE_ZERO_BYTE
10837                                | OPTI_TYPE_SLOW_HASH_SIMD;
10838                    dgst_pos0   = 0;
10839                    dgst_pos1   = 1;
10840                    dgst_pos2   = 2;
10841                    dgst_pos3   = 3;
10842                    break;
10843
10844       case 11000:  hash_type   = HASH_TYPE_MD5;
10845                    salt_type   = SALT_TYPE_INTERN;
10846                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10847                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10848                                | OPTS_TYPE_PT_ADD80;
10849                    kern_type   = KERN_TYPE_PRESTASHOP;
10850                    dgst_size   = DGST_SIZE_4_4;
10851                    parse_func  = prestashop_parse_hash;
10852                    sort_by_digest = sort_by_digest_4_4;
10853                    opti_type   = OPTI_TYPE_ZERO_BYTE
10854                                | OPTI_TYPE_PRECOMPUTE_INIT
10855                                | OPTI_TYPE_NOT_ITERATED
10856                                | OPTI_TYPE_PREPENDED_SALT;
10857                    dgst_pos0   = 0;
10858                    dgst_pos1   = 3;
10859                    dgst_pos2   = 2;
10860                    dgst_pos3   = 1;
10861                    break;
10862
10863       case 11100:  hash_type   = HASH_TYPE_MD5;
10864                    salt_type   = SALT_TYPE_EMBEDDED;
10865                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10866                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10867                                | OPTS_TYPE_ST_ADD80;
10868                    kern_type   = KERN_TYPE_POSTGRESQL_AUTH;
10869                    dgst_size   = DGST_SIZE_4_4;
10870                    parse_func  = postgresql_auth_parse_hash;
10871                    sort_by_digest = sort_by_digest_4_4;
10872                    opti_type   = OPTI_TYPE_ZERO_BYTE
10873                                | OPTI_TYPE_PRECOMPUTE_INIT
10874                                | OPTI_TYPE_PRECOMPUTE_MERKLE
10875                                | OPTI_TYPE_EARLY_SKIP;
10876                    dgst_pos0   = 0;
10877                    dgst_pos1   = 3;
10878                    dgst_pos2   = 2;
10879                    dgst_pos3   = 1;
10880                    break;
10881
10882       case 11200:  hash_type   = HASH_TYPE_SHA1;
10883                    salt_type   = SALT_TYPE_EMBEDDED;
10884                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10885                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
10886                                | OPTS_TYPE_PT_ADD80
10887                                | OPTS_TYPE_ST_HEX;
10888                    kern_type   = KERN_TYPE_MYSQL_AUTH;
10889                    dgst_size   = DGST_SIZE_4_5;
10890                    parse_func  = mysql_auth_parse_hash;
10891                    sort_by_digest = sort_by_digest_4_5;
10892                    opti_type   = OPTI_TYPE_ZERO_BYTE
10893                                | OPTI_TYPE_EARLY_SKIP;
10894                    dgst_pos0   = 3;
10895                    dgst_pos1   = 4;
10896                    dgst_pos2   = 2;
10897                    dgst_pos3   = 1;
10898                    break;
10899
10900       case 11300:  hash_type   = HASH_TYPE_BITCOIN_WALLET;
10901                    salt_type   = SALT_TYPE_EMBEDDED;
10902                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10903                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10904                                | OPTS_TYPE_ST_HEX
10905                                | OPTS_TYPE_ST_ADD80;
10906                    kern_type   = KERN_TYPE_BITCOIN_WALLET;
10907                    dgst_size   = DGST_SIZE_4_4;
10908                    parse_func  = bitcoin_wallet_parse_hash;
10909                    sort_by_digest = sort_by_digest_4_4;
10910                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10911                    dgst_pos0   = 0;
10912                    dgst_pos1   = 1;
10913                    dgst_pos2   = 2;
10914                    dgst_pos3   = 3;
10915                    break;
10916
10917       case 11400:  hash_type   = HASH_TYPE_MD5;
10918                    salt_type   = SALT_TYPE_EMBEDDED;
10919                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10920                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10921                                | OPTS_TYPE_PT_ADD80
10922                                | OPTS_TYPE_HASH_COPY;
10923                    kern_type   = KERN_TYPE_SIP_AUTH;
10924                    dgst_size   = DGST_SIZE_4_4;
10925                    parse_func  = sip_auth_parse_hash;
10926                    sort_by_digest = sort_by_digest_4_4;
10927                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10928                    dgst_pos0   = 0;
10929                    dgst_pos1   = 3;
10930                    dgst_pos2   = 2;
10931                    dgst_pos3   = 1;
10932                    break;
10933
10934       case 11500:  hash_type   = HASH_TYPE_CRC32;
10935                    salt_type   = SALT_TYPE_INTERN;
10936                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10937                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10938                                | OPTS_TYPE_ST_GENERATE_LE
10939                                | OPTS_TYPE_ST_HEX;
10940                    kern_type   = KERN_TYPE_CRC32;
10941                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10942                    parse_func  = crc32_parse_hash;
10943                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10944                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10945                    dgst_pos0   = 0;
10946                    dgst_pos1   = 1;
10947                    dgst_pos2   = 2;
10948                    dgst_pos3   = 3;
10949                    break;
10950
10951       case 11600:  hash_type   = HASH_TYPE_AES;
10952                    salt_type   = SALT_TYPE_EMBEDDED;
10953                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10954                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10955                                | OPTS_TYPE_PT_NEVERCRACK;
10956                    kern_type   = KERN_TYPE_SEVEN_ZIP;
10957                    dgst_size   = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10958                    parse_func  = seven_zip_parse_hash;
10959                    sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10960                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10961                    dgst_pos0   = 0;
10962                    dgst_pos1   = 1;
10963                    dgst_pos2   = 2;
10964                    dgst_pos3   = 3;
10965                    break;
10966
10967       case 11700:  hash_type   = HASH_TYPE_GOST_2012SBOG_256;
10968                    salt_type   = SALT_TYPE_NONE;
10969                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10970                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10971                                | OPTS_TYPE_PT_ADD01;
10972                    kern_type   = KERN_TYPE_GOST_2012SBOG_256;
10973                    dgst_size   = DGST_SIZE_4_8;
10974                    parse_func  = gost2012sbog_256_parse_hash;
10975                    sort_by_digest = sort_by_digest_4_8;
10976                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10977                    dgst_pos0   = 0;
10978                    dgst_pos1   = 1;
10979                    dgst_pos2   = 2;
10980                    dgst_pos3   = 3;
10981                    break;
10982
10983       case 11800:  hash_type   = HASH_TYPE_GOST_2012SBOG_512;
10984                    salt_type   = SALT_TYPE_NONE;
10985                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10986                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
10987                                | OPTS_TYPE_PT_ADD01;
10988                    kern_type   = KERN_TYPE_GOST_2012SBOG_512;
10989                    dgst_size   = DGST_SIZE_4_16;
10990                    parse_func  = gost2012sbog_512_parse_hash;
10991                    sort_by_digest = sort_by_digest_4_16;
10992                    opti_type   = OPTI_TYPE_ZERO_BYTE;
10993                    dgst_pos0   = 0;
10994                    dgst_pos1   = 1;
10995                    dgst_pos2   = 2;
10996                    dgst_pos3   = 3;
10997                    break;
10998
10999       case 11900:  hash_type   = HASH_TYPE_PBKDF2_MD5;
11000                    salt_type   = SALT_TYPE_EMBEDDED;
11001                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11002                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
11003                                | OPTS_TYPE_ST_BASE64
11004                                | OPTS_TYPE_HASH_COPY;
11005                    kern_type   = KERN_TYPE_PBKDF2_MD5;
11006                    dgst_size   = DGST_SIZE_4_32;
11007                    parse_func  = pbkdf2_md5_parse_hash;
11008                    sort_by_digest = sort_by_digest_4_32;
11009                    opti_type   = OPTI_TYPE_ZERO_BYTE
11010                                | OPTI_TYPE_SLOW_HASH_SIMD;
11011                    dgst_pos0   = 0;
11012                    dgst_pos1   = 1;
11013                    dgst_pos2   = 2;
11014                    dgst_pos3   = 3;
11015                    break;
11016
11017       case 12000:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
11018                    salt_type   = SALT_TYPE_EMBEDDED;
11019                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11020                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
11021                                | OPTS_TYPE_ST_BASE64
11022                                | OPTS_TYPE_HASH_COPY;
11023                    kern_type   = KERN_TYPE_PBKDF2_SHA1;
11024                    dgst_size   = DGST_SIZE_4_32;
11025                    parse_func  = pbkdf2_sha1_parse_hash;
11026                    sort_by_digest = sort_by_digest_4_32;
11027                    opti_type   = OPTI_TYPE_ZERO_BYTE
11028                                | OPTI_TYPE_SLOW_HASH_SIMD;
11029                    dgst_pos0   = 0;
11030                    dgst_pos1   = 1;
11031                    dgst_pos2   = 2;
11032                    dgst_pos3   = 3;
11033                    break;
11034
11035       case 12100:  hash_type   = HASH_TYPE_PBKDF2_SHA512;
11036                    salt_type   = SALT_TYPE_EMBEDDED;
11037                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11038                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
11039                                | OPTS_TYPE_ST_BASE64
11040                                | OPTS_TYPE_HASH_COPY;
11041                    kern_type   = KERN_TYPE_PBKDF2_SHA512;
11042                    dgst_size   = DGST_SIZE_8_16;
11043                    parse_func  = pbkdf2_sha512_parse_hash;
11044                    sort_by_digest = sort_by_digest_8_16;
11045                    opti_type   = OPTI_TYPE_ZERO_BYTE
11046                                | OPTI_TYPE_USES_BITS_64
11047                                | OPTI_TYPE_SLOW_HASH_SIMD;
11048                    dgst_pos0   = 0;
11049                    dgst_pos1   = 1;
11050                    dgst_pos2   = 2;
11051                    dgst_pos3   = 3;
11052                    break;
11053
11054       case 12200:  hash_type   = HASH_TYPE_ECRYPTFS;
11055                    salt_type   = SALT_TYPE_EMBEDDED;
11056                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11057                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11058                    kern_type   = KERN_TYPE_ECRYPTFS;
11059                    dgst_size   = DGST_SIZE_8_8;
11060                    parse_func  = ecryptfs_parse_hash;
11061                    sort_by_digest = sort_by_digest_8_8;
11062                    opti_type   = OPTI_TYPE_ZERO_BYTE
11063                                | OPTI_TYPE_USES_BITS_64;
11064                    dgst_pos0   = 0;
11065                    dgst_pos1   = 1;
11066                    dgst_pos2   = 2;
11067                    dgst_pos3   = 3;
11068                    break;
11069
11070       case 12300:  hash_type   = HASH_TYPE_ORACLET;
11071                    salt_type   = SALT_TYPE_EMBEDDED;
11072                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11073                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11074                    kern_type   = KERN_TYPE_ORACLET;
11075                    dgst_size   = DGST_SIZE_8_16;
11076                    parse_func  = oraclet_parse_hash;
11077                    sort_by_digest = sort_by_digest_8_16;
11078                    opti_type   = OPTI_TYPE_ZERO_BYTE
11079                                | OPTI_TYPE_USES_BITS_64;
11080                    dgst_pos0   = 0;
11081                    dgst_pos1   = 1;
11082                    dgst_pos2   = 2;
11083                    dgst_pos3   = 3;
11084                    break;
11085
11086       case 12400:  hash_type   = HASH_TYPE_BSDICRYPT;
11087                    salt_type   = SALT_TYPE_EMBEDDED;
11088                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11089                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11090                    kern_type   = KERN_TYPE_BSDICRYPT;
11091                    dgst_size   = DGST_SIZE_4_4;
11092                    parse_func  = bsdicrypt_parse_hash;
11093                    sort_by_digest = sort_by_digest_4_4;
11094                    opti_type   = OPTI_TYPE_ZERO_BYTE
11095                                | OPTI_TYPE_PRECOMPUTE_PERMUT;
11096                    dgst_pos0   = 0;
11097                    dgst_pos1   = 1;
11098                    dgst_pos2   = 2;
11099                    dgst_pos3   = 3;
11100                    break;
11101
11102       case 12500:  hash_type   = HASH_TYPE_RAR3HP;
11103                    salt_type   = SALT_TYPE_EMBEDDED;
11104                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11105                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11106                    kern_type   = KERN_TYPE_RAR3;
11107                    dgst_size   = DGST_SIZE_4_4;
11108                    parse_func  = rar3hp_parse_hash;
11109                    sort_by_digest = sort_by_digest_4_4;
11110                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11111                    dgst_pos0   = 0;
11112                    dgst_pos1   = 1;
11113                    dgst_pos2   = 2;
11114                    dgst_pos3   = 3;
11115                    break;
11116
11117       case 12600:  hash_type   = HASH_TYPE_SHA256;
11118                    salt_type   = SALT_TYPE_INTERN;
11119                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11120                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11121                                | OPTS_TYPE_PT_ADD80;
11122                    kern_type   = KERN_TYPE_CF10;
11123                    dgst_size   = DGST_SIZE_4_8;
11124                    parse_func  = cf10_parse_hash;
11125                    sort_by_digest = sort_by_digest_4_8;
11126                    opti_type   = OPTI_TYPE_ZERO_BYTE
11127                                | OPTI_TYPE_PRECOMPUTE_INIT
11128                                | OPTI_TYPE_EARLY_SKIP
11129                                | OPTI_TYPE_NOT_ITERATED;
11130                    dgst_pos0   = 3;
11131                    dgst_pos1   = 7;
11132                    dgst_pos2   = 2;
11133                    dgst_pos3   = 6;
11134                    break;
11135
11136       case 12700:  hash_type   = HASH_TYPE_AES;
11137                    salt_type   = SALT_TYPE_EMBEDDED;
11138                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11139                    opts_type   = OPTS_TYPE_PT_GENERATE_LE
11140                                | OPTS_TYPE_HASH_COPY;
11141                    kern_type   = KERN_TYPE_MYWALLET;
11142                    dgst_size   = DGST_SIZE_4_5; // because kernel uses _SHA1_
11143                    parse_func  = mywallet_parse_hash;
11144                    sort_by_digest = sort_by_digest_4_5;
11145                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11146                    dgst_pos0   = 0;
11147                    dgst_pos1   = 1;
11148                    dgst_pos2   = 2;
11149                    dgst_pos3   = 3;
11150                    break;
11151
11152       case 12800:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
11153                    salt_type   = SALT_TYPE_EMBEDDED;
11154                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11155                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11156                    kern_type   = KERN_TYPE_MS_DRSR;
11157                    dgst_size   = DGST_SIZE_4_8;
11158                    parse_func  = ms_drsr_parse_hash;
11159                    sort_by_digest = sort_by_digest_4_8;
11160                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11161                    dgst_pos0   = 0;
11162                    dgst_pos1   = 1;
11163                    dgst_pos2   = 2;
11164                    dgst_pos3   = 3;
11165                    break;
11166
11167       case 12900:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
11168                    salt_type   = SALT_TYPE_EMBEDDED;
11169                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11170                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11171                    kern_type   = KERN_TYPE_ANDROIDFDE_SAMSUNG;
11172                    dgst_size   = DGST_SIZE_4_8;
11173                    parse_func  = androidfde_samsung_parse_hash;
11174                    sort_by_digest = sort_by_digest_4_8;
11175                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11176                    dgst_pos0   = 0;
11177                    dgst_pos1   = 1;
11178                    dgst_pos2   = 2;
11179                    dgst_pos3   = 3;
11180                    break;
11181
11182       case 13000:  hash_type   = HASH_TYPE_PBKDF2_SHA256;
11183                    salt_type   = SALT_TYPE_EMBEDDED;
11184                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11185                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11186                    kern_type   = KERN_TYPE_RAR5;
11187                    dgst_size   = DGST_SIZE_4_4;
11188                    parse_func  = rar5_parse_hash;
11189                    sort_by_digest = sort_by_digest_4_4;
11190                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11191                    dgst_pos0   = 0;
11192                    dgst_pos1   = 1;
11193                    dgst_pos2   = 2;
11194                    dgst_pos3   = 3;
11195                    break;
11196
11197       case 13100:  hash_type   = HASH_TYPE_KRB5TGS;
11198                    salt_type   = SALT_TYPE_EMBEDDED;
11199                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11200                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11201                    kern_type   = KERN_TYPE_KRB5TGS;
11202                    dgst_size   = DGST_SIZE_4_4;
11203                    parse_func  = krb5tgs_parse_hash;
11204                    sort_by_digest = sort_by_digest_4_4;
11205                    opti_type   = OPTI_TYPE_ZERO_BYTE
11206                                | OPTI_TYPE_NOT_ITERATED;
11207                    dgst_pos0   = 0;
11208                    dgst_pos1   = 1;
11209                    dgst_pos2   = 2;
11210                    dgst_pos3   = 3;
11211                    break;
11212
11213       case 13200:  hash_type   = HASH_TYPE_AES;
11214                    salt_type   = SALT_TYPE_EMBEDDED;
11215                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11216                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11217                    kern_type   = KERN_TYPE_AXCRYPT;
11218                    dgst_size   = DGST_SIZE_4_4;
11219                    parse_func  = axcrypt_parse_hash;
11220                    sort_by_digest = sort_by_digest_4_4;
11221                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11222                    dgst_pos0   = 0;
11223                    dgst_pos1   = 1;
11224                    dgst_pos2   = 2;
11225                    dgst_pos3   = 3;
11226                    break;
11227
11228       case 13300:  hash_type   = HASH_TYPE_SHA1;
11229                    salt_type   = SALT_TYPE_NONE;
11230                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11231                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11232                                | OPTS_TYPE_PT_ADD80
11233                                | OPTS_TYPE_PT_ADDBITS15;
11234                    kern_type   = KERN_TYPE_SHA1_AXCRYPT;
11235                    dgst_size   = DGST_SIZE_4_5;
11236                    parse_func  = sha1axcrypt_parse_hash;
11237                    sort_by_digest = sort_by_digest_4_5;
11238                    opti_type   = OPTI_TYPE_ZERO_BYTE
11239                                | OPTI_TYPE_PRECOMPUTE_INIT
11240                                | OPTI_TYPE_EARLY_SKIP
11241                                | OPTI_TYPE_NOT_ITERATED
11242                                | OPTI_TYPE_NOT_SALTED;
11243                    dgst_pos0   = 0;
11244                    dgst_pos1   = 4;
11245                    dgst_pos2   = 3;
11246                    dgst_pos3   = 2;
11247                    break;
11248
11249       case 13400:  hash_type   = HASH_TYPE_AES;
11250                    salt_type   = SALT_TYPE_EMBEDDED;
11251                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11252                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11253                    kern_type   = KERN_TYPE_KEEPASS;
11254                    dgst_size   = DGST_SIZE_4_4;
11255                    parse_func  = keepass_parse_hash;
11256                    sort_by_digest = sort_by_digest_4_4;
11257                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11258                    dgst_pos0   = 0;
11259                    dgst_pos1   = 1;
11260                    dgst_pos2   = 2;
11261                    dgst_pos3   = 3;
11262                    break;
11263
11264       case 13500:  hash_type   = HASH_TYPE_SHA1;
11265                    salt_type   = SALT_TYPE_EMBEDDED;
11266                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11267                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11268                                | OPTS_TYPE_PT_UNICODE
11269                                | OPTS_TYPE_PT_ADD80;
11270                    kern_type   = KERN_TYPE_PSTOKEN;
11271                    dgst_size   = DGST_SIZE_4_5;
11272                    parse_func  = pstoken_parse_hash;
11273                    sort_by_digest = sort_by_digest_4_5;
11274                    opti_type   = OPTI_TYPE_ZERO_BYTE
11275                                | OPTI_TYPE_PRECOMPUTE_INIT
11276                                | OPTI_TYPE_EARLY_SKIP
11277                                | OPTI_TYPE_NOT_ITERATED
11278                                | OPTI_TYPE_PREPENDED_SALT
11279                                | OPTI_TYPE_RAW_HASH;
11280                    dgst_pos0   = 3;
11281                    dgst_pos1   = 4;
11282                    dgst_pos2   = 2;
11283                    dgst_pos3   = 1;
11284                    break;
11285
11286       case 13600:  hash_type   = HASH_TYPE_PBKDF2_SHA1;
11287                    salt_type   = SALT_TYPE_EMBEDDED;
11288                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11289                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11290                    kern_type   = KERN_TYPE_ZIP2;
11291                    dgst_size   = DGST_SIZE_4_4;
11292                    parse_func  = zip2_parse_hash;
11293                    sort_by_digest = sort_by_digest_4_4;
11294                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11295                    dgst_pos0   = 0;
11296                    dgst_pos1   = 1;
11297                    dgst_pos2   = 2;
11298                    dgst_pos3   = 3;
11299                    break;
11300
11301       case 13711:  hash_type   = HASH_TYPE_RIPEMD160;
11302                    salt_type   = SALT_TYPE_EMBEDDED;
11303                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11304                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11305                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
11306                    dgst_size   = DGST_SIZE_4_5;
11307                    parse_func  = veracrypt_parse_hash_655331;
11308                    sort_by_digest = sort_by_digest_4_5;
11309                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11310                    dgst_pos0   = 0;
11311                    dgst_pos1   = 1;
11312                    dgst_pos2   = 2;
11313                    dgst_pos3   = 3;
11314                    break;
11315
11316       case 13712:  hash_type   = HASH_TYPE_RIPEMD160;
11317                    salt_type   = SALT_TYPE_EMBEDDED;
11318                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11319                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11320                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
11321                    dgst_size   = DGST_SIZE_4_5;
11322                    parse_func  = veracrypt_parse_hash_655331;
11323                    sort_by_digest = sort_by_digest_4_5;
11324                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11325                    dgst_pos0   = 0;
11326                    dgst_pos1   = 1;
11327                    dgst_pos2   = 2;
11328                    dgst_pos3   = 3;
11329                    break;
11330
11331       case 13713:  hash_type   = HASH_TYPE_RIPEMD160;
11332                    salt_type   = SALT_TYPE_EMBEDDED;
11333                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11334                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11335                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
11336                    dgst_size   = DGST_SIZE_4_5;
11337                    parse_func  = veracrypt_parse_hash_655331;
11338                    sort_by_digest = sort_by_digest_4_5;
11339                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11340                    dgst_pos0   = 0;
11341                    dgst_pos1   = 1;
11342                    dgst_pos2   = 2;
11343                    dgst_pos3   = 3;
11344                    break;
11345
11346       case 13721:  hash_type   = HASH_TYPE_SHA512;
11347                    salt_type   = SALT_TYPE_EMBEDDED;
11348                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11349                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11350                    kern_type   = KERN_TYPE_TCSHA512_XTS512;
11351                    dgst_size   = DGST_SIZE_8_8;
11352                    parse_func  = veracrypt_parse_hash_500000;
11353                    sort_by_digest = sort_by_digest_8_8;
11354                    opti_type   = OPTI_TYPE_ZERO_BYTE
11355                                | OPTI_TYPE_USES_BITS_64;
11356                    dgst_pos0   = 0;
11357                    dgst_pos1   = 1;
11358                    dgst_pos2   = 2;
11359                    dgst_pos3   = 3;
11360                    break;
11361
11362       case 13722:  hash_type   = HASH_TYPE_SHA512;
11363                    salt_type   = SALT_TYPE_EMBEDDED;
11364                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11365                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11366                    kern_type   = KERN_TYPE_TCSHA512_XTS1024;
11367                    dgst_size   = DGST_SIZE_8_8;
11368                    parse_func  = veracrypt_parse_hash_500000;
11369                    sort_by_digest = sort_by_digest_8_8;
11370                    opti_type   = OPTI_TYPE_ZERO_BYTE
11371                                | OPTI_TYPE_USES_BITS_64;
11372                    dgst_pos0   = 0;
11373                    dgst_pos1   = 1;
11374                    dgst_pos2   = 2;
11375                    dgst_pos3   = 3;
11376                    break;
11377
11378       case 13723:  hash_type   = HASH_TYPE_SHA512;
11379                    salt_type   = SALT_TYPE_EMBEDDED;
11380                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11381                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11382                    kern_type   = KERN_TYPE_TCSHA512_XTS1536;
11383                    dgst_size   = DGST_SIZE_8_8;
11384                    parse_func  = veracrypt_parse_hash_500000;
11385                    sort_by_digest = sort_by_digest_8_8;
11386                    opti_type   = OPTI_TYPE_ZERO_BYTE
11387                                | OPTI_TYPE_USES_BITS_64;
11388                    dgst_pos0   = 0;
11389                    dgst_pos1   = 1;
11390                    dgst_pos2   = 2;
11391                    dgst_pos3   = 3;
11392                    break;
11393
11394       case 13731:  hash_type   = HASH_TYPE_WHIRLPOOL;
11395                    salt_type   = SALT_TYPE_EMBEDDED;
11396                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11397                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11398                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS512;
11399                    dgst_size   = DGST_SIZE_4_8;
11400                    parse_func  = veracrypt_parse_hash_500000;
11401                    sort_by_digest = sort_by_digest_4_8;
11402                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11403                    dgst_pos0   = 0;
11404                    dgst_pos1   = 1;
11405                    dgst_pos2   = 2;
11406                    dgst_pos3   = 3;
11407                    break;
11408
11409       case 13732:  hash_type   = HASH_TYPE_WHIRLPOOL;
11410                    salt_type   = SALT_TYPE_EMBEDDED;
11411                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11412                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11413                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11414                    dgst_size   = DGST_SIZE_4_8;
11415                    parse_func  = veracrypt_parse_hash_500000;
11416                    sort_by_digest = sort_by_digest_4_8;
11417                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11418                    dgst_pos0   = 0;
11419                    dgst_pos1   = 1;
11420                    dgst_pos2   = 2;
11421                    dgst_pos3   = 3;
11422                    break;
11423
11424       case 13733:  hash_type   = HASH_TYPE_WHIRLPOOL;
11425                    salt_type   = SALT_TYPE_EMBEDDED;
11426                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11427                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11428                    kern_type   = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11429                    dgst_size   = DGST_SIZE_4_8;
11430                    parse_func  = veracrypt_parse_hash_500000;
11431                    sort_by_digest = sort_by_digest_4_8;
11432                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11433                    dgst_pos0   = 0;
11434                    dgst_pos1   = 1;
11435                    dgst_pos2   = 2;
11436                    dgst_pos3   = 3;
11437                    break;
11438
11439       case 13741:  hash_type   = HASH_TYPE_RIPEMD160;
11440                    salt_type   = SALT_TYPE_EMBEDDED;
11441                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11442                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11443                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS512;
11444                    dgst_size   = DGST_SIZE_4_5;
11445                    parse_func  = veracrypt_parse_hash_327661;
11446                    sort_by_digest = sort_by_digest_4_5;
11447                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11448                    dgst_pos0   = 0;
11449                    dgst_pos1   = 1;
11450                    dgst_pos2   = 2;
11451                    dgst_pos3   = 3;
11452                    break;
11453
11454       case 13742:  hash_type   = HASH_TYPE_RIPEMD160;
11455                    salt_type   = SALT_TYPE_EMBEDDED;
11456                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11457                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11458                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1024;
11459                    dgst_size   = DGST_SIZE_4_5;
11460                    parse_func  = veracrypt_parse_hash_327661;
11461                    sort_by_digest = sort_by_digest_4_5;
11462                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11463                    dgst_pos0   = 0;
11464                    dgst_pos1   = 1;
11465                    dgst_pos2   = 2;
11466                    dgst_pos3   = 3;
11467                    break;
11468
11469       case 13743:  hash_type   = HASH_TYPE_RIPEMD160;
11470                    salt_type   = SALT_TYPE_EMBEDDED;
11471                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11472                    opts_type   = OPTS_TYPE_PT_GENERATE_LE;
11473                    kern_type   = KERN_TYPE_TCRIPEMD160_XTS1536;
11474                    dgst_size   = DGST_SIZE_4_5;
11475                    parse_func  = veracrypt_parse_hash_327661;
11476                    sort_by_digest = sort_by_digest_4_5;
11477                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11478                    dgst_pos0   = 0;
11479                    dgst_pos1   = 1;
11480                    dgst_pos2   = 2;
11481                    dgst_pos3   = 3;
11482                    break;
11483
11484       case 13751:  hash_type   = HASH_TYPE_SHA256;
11485                    salt_type   = SALT_TYPE_EMBEDDED;
11486                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11487                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11488                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11489                    dgst_size   = DGST_SIZE_4_8;
11490                    parse_func  = veracrypt_parse_hash_500000;
11491                    sort_by_digest = sort_by_digest_4_8;
11492                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11493                    dgst_pos0   = 0;
11494                    dgst_pos1   = 1;
11495                    dgst_pos2   = 2;
11496                    dgst_pos3   = 3;
11497                    break;
11498
11499       case 13752:  hash_type   = HASH_TYPE_SHA256;
11500                    salt_type   = SALT_TYPE_EMBEDDED;
11501                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11502                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11503                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11504                    dgst_size   = DGST_SIZE_4_8;
11505                    parse_func  = veracrypt_parse_hash_500000;
11506                    sort_by_digest = sort_by_digest_4_8;
11507                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11508                    dgst_pos0   = 0;
11509                    dgst_pos1   = 1;
11510                    dgst_pos2   = 2;
11511                    dgst_pos3   = 3;
11512                    break;
11513
11514       case 13753:  hash_type   = HASH_TYPE_SHA256;
11515                    salt_type   = SALT_TYPE_EMBEDDED;
11516                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11517                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11518                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11519                    dgst_size   = DGST_SIZE_4_8;
11520                    parse_func  = veracrypt_parse_hash_500000;
11521                    sort_by_digest = sort_by_digest_4_8;
11522                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11523                    dgst_pos0   = 0;
11524                    dgst_pos1   = 1;
11525                    dgst_pos2   = 2;
11526                    dgst_pos3   = 3;
11527                    break;
11528
11529       case 13761:  hash_type   = HASH_TYPE_SHA256;
11530                    salt_type   = SALT_TYPE_EMBEDDED;
11531                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11532                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11533                    kern_type   = KERN_TYPE_VCSHA256_XTS512;
11534                    dgst_size   = DGST_SIZE_4_8;
11535                    parse_func  = veracrypt_parse_hash_200000;
11536                    sort_by_digest = sort_by_digest_4_8;
11537                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11538                    dgst_pos0   = 0;
11539                    dgst_pos1   = 1;
11540                    dgst_pos2   = 2;
11541                    dgst_pos3   = 3;
11542                    break;
11543
11544       case 13762:  hash_type   = HASH_TYPE_SHA256;
11545                    salt_type   = SALT_TYPE_EMBEDDED;
11546                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11547                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11548                    kern_type   = KERN_TYPE_VCSHA256_XTS1024;
11549                    dgst_size   = DGST_SIZE_4_8;
11550                    parse_func  = veracrypt_parse_hash_200000;
11551                    sort_by_digest = sort_by_digest_4_8;
11552                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11553                    dgst_pos0   = 0;
11554                    dgst_pos1   = 1;
11555                    dgst_pos2   = 2;
11556                    dgst_pos3   = 3;
11557                    break;
11558
11559       case 13763:  hash_type   = HASH_TYPE_SHA256;
11560                    salt_type   = SALT_TYPE_EMBEDDED;
11561                    attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11562                    opts_type   = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11563                    kern_type   = KERN_TYPE_VCSHA256_XTS1536;
11564                    dgst_size   = DGST_SIZE_4_8;
11565                    parse_func  = veracrypt_parse_hash_200000;
11566                    sort_by_digest = sort_by_digest_4_8;
11567                    opti_type   = OPTI_TYPE_ZERO_BYTE;
11568                    dgst_pos0   = 0;
11569                    dgst_pos1   = 1;
11570                    dgst_pos2   = 2;
11571                    dgst_pos3   = 3;
11572                    break;
11573
11574       case 13800:  hash_type   = HASH_TYPE_SHA256;
11575                    salt_type   = SALT_TYPE_EMBEDDED;
11576                    attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11577                    opts_type   = OPTS_TYPE_PT_GENERATE_BE
11578                                | OPTS_TYPE_PT_UNICODE;
11579                    kern_type   = KERN_TYPE_WIN8PHONE;
11580                    dgst_size   = DGST_SIZE_4_8;
11581                    parse_func  = win8phone_parse_hash;
11582                    sort_by_digest = sort_by_digest_4_8;
11583                    opti_type   = OPTI_TYPE_ZERO_BYTE
11584                                | OPTI_TYPE_PRECOMPUTE_INIT
11585                                | OPTI_TYPE_EARLY_SKIP
11586                                | OPTI_TYPE_NOT_ITERATED
11587                                | OPTI_TYPE_RAW_HASH;
11588                    dgst_pos0   = 3;
11589                    dgst_pos1   = 7;
11590                    dgst_pos2   = 2;
11591                    dgst_pos3   = 6;
11592                    break;
11593
11594       default:     usage_mini_print (PROGNAME); return -1;
11595     }
11596
11597     /**
11598      * parser
11599      */
11600
11601     data.parse_func = parse_func;
11602
11603     /**
11604      * misc stuff
11605      */
11606
11607     if (hex_salt)
11608     {
11609       if (salt_type == SALT_TYPE_INTERN)
11610       {
11611         opts_type |= OPTS_TYPE_ST_HEX;
11612       }
11613       else
11614       {
11615         log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11616
11617         return -1;
11618       }
11619     }
11620
11621     uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11622                   |  (salt_type == SALT_TYPE_EXTERN)
11623                   |  (salt_type == SALT_TYPE_EMBEDDED)
11624                   |  (salt_type == SALT_TYPE_VIRTUAL));
11625
11626     sort_by_digest = sort_by_digest_p0p1;  // overruled by 64 bit digest
11627
11628     data.hash_type   = hash_type;
11629     data.attack_mode = attack_mode;
11630     data.attack_kern = attack_kern;
11631     data.attack_exec = attack_exec;
11632     data.kern_type   = kern_type;
11633     data.opts_type   = opts_type;
11634     data.dgst_size   = dgst_size;
11635     data.salt_type   = salt_type;
11636     data.isSalted    = isSalted;
11637     data.sort_by_digest = sort_by_digest;
11638     data.dgst_pos0   = dgst_pos0;
11639     data.dgst_pos1   = dgst_pos1;
11640     data.dgst_pos2   = dgst_pos2;
11641     data.dgst_pos3   = dgst_pos3;
11642
11643     esalt_size = 0;
11644
11645     switch (hash_mode)
11646     {
11647       case  2500:  esalt_size = sizeof (wpa_t);           break;
11648       case  5300:  esalt_size = sizeof (ikepsk_t);        break;
11649       case  5400:  esalt_size = sizeof (ikepsk_t);        break;
11650       case  5500:  esalt_size = sizeof (netntlm_t);       break;
11651       case  5600:  esalt_size = sizeof (netntlm_t);       break;
11652       case  6211:  esalt_size = sizeof (tc_t);            break;
11653       case  6212:  esalt_size = sizeof (tc_t);            break;
11654       case  6213:  esalt_size = sizeof (tc_t);            break;
11655       case  6221:  esalt_size = sizeof (tc_t);            break;
11656       case  6222:  esalt_size = sizeof (tc_t);            break;
11657       case  6223:  esalt_size = sizeof (tc_t);            break;
11658       case  6231:  esalt_size = sizeof (tc_t);            break;
11659       case  6232:  esalt_size = sizeof (tc_t);            break;
11660       case  6233:  esalt_size = sizeof (tc_t);            break;
11661       case  6241:  esalt_size = sizeof (tc_t);            break;
11662       case  6242:  esalt_size = sizeof (tc_t);            break;
11663       case  6243:  esalt_size = sizeof (tc_t);            break;
11664       case  6600:  esalt_size = sizeof (agilekey_t);      break;
11665       case  7100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11666       case  7200:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11667       case  7300:  esalt_size = sizeof (rakp_t);          break;
11668       case  7500:  esalt_size = sizeof (krb5pa_t);        break;
11669       case  8200:  esalt_size = sizeof (cloudkey_t);      break;
11670       case  8800:  esalt_size = sizeof (androidfde_t);    break;
11671       case  9200:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11672       case  9400:  esalt_size = sizeof (office2007_t);    break;
11673       case  9500:  esalt_size = sizeof (office2010_t);    break;
11674       case  9600:  esalt_size = sizeof (office2013_t);    break;
11675       case  9700:  esalt_size = sizeof (oldoffice01_t);   break;
11676       case  9710:  esalt_size = sizeof (oldoffice01_t);   break;
11677       case  9720:  esalt_size = sizeof (oldoffice01_t);   break;
11678       case  9800:  esalt_size = sizeof (oldoffice34_t);   break;
11679       case  9810:  esalt_size = sizeof (oldoffice34_t);   break;
11680       case  9820:  esalt_size = sizeof (oldoffice34_t);   break;
11681       case 10000:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11682       case 10200:  esalt_size = sizeof (cram_md5_t);      break;
11683       case 10400:  esalt_size = sizeof (pdf_t);           break;
11684       case 10410:  esalt_size = sizeof (pdf_t);           break;
11685       case 10420:  esalt_size = sizeof (pdf_t);           break;
11686       case 10500:  esalt_size = sizeof (pdf_t);           break;
11687       case 10600:  esalt_size = sizeof (pdf_t);           break;
11688       case 10700:  esalt_size = sizeof (pdf_t);           break;
11689       case 10900:  esalt_size = sizeof (pbkdf2_sha256_t); break;
11690       case 11300:  esalt_size = sizeof (bitcoin_wallet_t); break;
11691       case 11400:  esalt_size = sizeof (sip_t);           break;
11692       case 11600:  esalt_size = sizeof (seven_zip_t);     break;
11693       case 11900:  esalt_size = sizeof (pbkdf2_md5_t);    break;
11694       case 12000:  esalt_size = sizeof (pbkdf2_sha1_t);   break;
11695       case 12100:  esalt_size = sizeof (pbkdf2_sha512_t); break;
11696       case 13000:  esalt_size = sizeof (rar5_t);          break;
11697       case 13100:  esalt_size = sizeof (krb5tgs_t);       break;
11698       case 13400:  esalt_size = sizeof (keepass_t);       break;
11699       case 13500:  esalt_size = sizeof (pstoken_t);       break;
11700       case 13600:  esalt_size = sizeof (zip2_t);          break;
11701       case 13711:  esalt_size = sizeof (tc_t);            break;
11702       case 13712:  esalt_size = sizeof (tc_t);            break;
11703       case 13713:  esalt_size = sizeof (tc_t);            break;
11704       case 13721:  esalt_size = sizeof (tc_t);            break;
11705       case 13722:  esalt_size = sizeof (tc_t);            break;
11706       case 13723:  esalt_size = sizeof (tc_t);            break;
11707       case 13731:  esalt_size = sizeof (tc_t);            break;
11708       case 13732:  esalt_size = sizeof (tc_t);            break;
11709       case 13733:  esalt_size = sizeof (tc_t);            break;
11710       case 13741:  esalt_size = sizeof (tc_t);            break;
11711       case 13742:  esalt_size = sizeof (tc_t);            break;
11712       case 13743:  esalt_size = sizeof (tc_t);            break;
11713       case 13751:  esalt_size = sizeof (tc_t);            break;
11714       case 13752:  esalt_size = sizeof (tc_t);            break;
11715       case 13753:  esalt_size = sizeof (tc_t);            break;
11716       case 13761:  esalt_size = sizeof (tc_t);            break;
11717       case 13762:  esalt_size = sizeof (tc_t);            break;
11718       case 13763:  esalt_size = sizeof (tc_t);            break;
11719       case 13800:  esalt_size = sizeof (win8phone_t);     break;
11720     }
11721
11722     data.esalt_size = esalt_size;
11723
11724     /**
11725      * choose dictionary parser
11726      */
11727
11728     if (hash_type == HASH_TYPE_LM)
11729     {
11730       get_next_word_func = get_next_word_lm;
11731     }
11732     else if (opts_type & OPTS_TYPE_PT_UPPER)
11733     {
11734       get_next_word_func = get_next_word_uc;
11735     }
11736     else
11737     {
11738       get_next_word_func = get_next_word_std;
11739     }
11740
11741     /**
11742      * dictstat
11743      */
11744
11745     dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11746
11747     #ifdef _POSIX
11748     size_t dictstat_nmemb = 0;
11749     #endif
11750
11751     #ifdef _WIN
11752     uint   dictstat_nmemb = 0;
11753     #endif
11754
11755     char dictstat[256] = { 0 };
11756
11757     FILE *dictstat_fp = NULL;
11758
11759     if (keyspace == 0)
11760     {
11761       snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11762
11763       dictstat_fp = fopen (dictstat, "rb");
11764
11765       if (dictstat_fp)
11766       {
11767         #ifdef _POSIX
11768         struct stat tmpstat;
11769
11770         fstat (fileno (dictstat_fp), &tmpstat);
11771         #endif
11772
11773         #ifdef _WIN
11774         struct stat64 tmpstat;
11775
11776         _fstat64 (fileno (dictstat_fp), &tmpstat);
11777         #endif
11778
11779         if (tmpstat.st_mtime < COMPTIME)
11780         {
11781           /* with v0.15 the format changed so we have to ensure user is using a good version
11782              since there is no version-header in the dictstat file */
11783
11784           fclose (dictstat_fp);
11785
11786           unlink (dictstat);
11787         }
11788         else
11789         {
11790           while (!feof (dictstat_fp))
11791           {
11792             dictstat_t d;
11793
11794             if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11795
11796             lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11797
11798             if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11799             {
11800               log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11801
11802               return -1;
11803             }
11804           }
11805
11806           fclose (dictstat_fp);
11807         }
11808       }
11809     }
11810
11811     /**
11812      * potfile
11813      */
11814
11815     char potfile[256] = { 0 };
11816
11817     if (potfile_path == NULL)
11818     {
11819       snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11820     }
11821     else
11822     {
11823       strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11824     }
11825
11826     data.pot_fp = NULL;
11827
11828     FILE *out_fp = NULL;
11829     FILE *pot_fp = NULL;
11830
11831     if (show == 1 || left == 1)
11832     {
11833       pot_fp = fopen (potfile, "rb");
11834
11835       if (pot_fp == NULL)
11836       {
11837         log_error ("ERROR: %s: %s", potfile, strerror (errno));
11838
11839         return -1;
11840       }
11841
11842       if (outfile != NULL)
11843       {
11844         if ((out_fp = fopen (outfile, "ab")) == NULL)
11845         {
11846           log_error ("ERROR: %s: %s", outfile, strerror (errno));
11847
11848           fclose (pot_fp);
11849
11850           return -1;
11851         }
11852       }
11853       else
11854       {
11855         out_fp = stdout;
11856       }
11857     }
11858     else
11859     {
11860       if (potfile_disable == 0)
11861       {
11862         pot_fp = fopen (potfile, "ab");
11863
11864         if (pot_fp == NULL)
11865         {
11866           log_error ("ERROR: %s: %s", potfile, strerror (errno));
11867
11868           return -1;
11869         }
11870
11871         data.pot_fp = pot_fp;
11872       }
11873     }
11874
11875     pot_t *pot = NULL;
11876
11877     uint pot_cnt   = 0;
11878     uint pot_avail = 0;
11879
11880     if (show == 1 || left == 1)
11881     {
11882       SUPPRESS_OUTPUT = 1;
11883
11884       pot_avail = count_lines (pot_fp);
11885
11886       rewind (pot_fp);
11887
11888       pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11889
11890       uint pot_hashes_avail = 0;
11891
11892       uint line_num = 0;
11893
11894       char *line_buf = (char *) mymalloc (HCBUFSIZ);
11895
11896       while (!feof (pot_fp))
11897       {
11898         line_num++;
11899
11900         int line_len = fgetl (pot_fp, line_buf);
11901
11902         if (line_len == 0) continue;
11903
11904         char *plain_buf = line_buf + line_len;
11905
11906         pot_t *pot_ptr = &pot[pot_cnt];
11907
11908         hash_t *hashes_buf = &pot_ptr->hash;
11909
11910         // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11911         // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11912
11913         if (pot_cnt == pot_hashes_avail)
11914         {
11915           uint pos = 0;
11916
11917           for (pos = 0; pos < INCR_POT; pos++)
11918           {
11919             if ((pot_cnt + pos) >= pot_avail) break;
11920
11921             pot_t *tmp_pot = &pot[pot_cnt + pos];
11922
11923             hash_t *tmp_hash = &tmp_pot->hash;
11924
11925             tmp_hash->digest = mymalloc (dgst_size);
11926
11927             if (isSalted)
11928             {
11929               tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11930             }
11931
11932             if (esalt_size)
11933             {
11934               tmp_hash->esalt = mymalloc (esalt_size);
11935             }
11936
11937             pot_hashes_avail++;
11938           }
11939         }
11940
11941         int plain_len = 0;
11942
11943         int parser_status;
11944
11945         int iter = MAX_CUT_TRIES;
11946
11947         do
11948         {
11949           for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11950           {
11951             if (line_buf[i] == ':')
11952             {
11953               line_len--;
11954
11955               break;
11956             }
11957           }
11958
11959           if (data.hash_mode != 2500)
11960           {
11961             parser_status = parse_func (line_buf, line_len, hashes_buf);
11962           }
11963           else
11964           {
11965             int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11966
11967             if (line_len > max_salt_size)
11968             {
11969               parser_status = PARSER_GLOBAL_LENGTH;
11970             }
11971             else
11972             {
11973               memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11974
11975               memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11976
11977               hashes_buf->salt->salt_len = line_len;
11978
11979               parser_status = PARSER_OK;
11980             }
11981           }
11982
11983           // if NOT parsed without error, we add the ":" to the plain
11984
11985           if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11986           {
11987             plain_len++;
11988             plain_buf--;
11989           }
11990
11991         } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11992
11993         if (parser_status < PARSER_GLOBAL_ZERO)
11994         {
11995           // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11996
11997           continue;
11998         }
11999
12000         if (plain_len >= 255) continue;
12001
12002         memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
12003
12004         pot_ptr->plain_len = plain_len;
12005
12006         pot_cnt++;
12007       }
12008
12009       myfree (line_buf);
12010
12011       fclose (pot_fp);
12012
12013       SUPPRESS_OUTPUT = 0;
12014
12015       qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
12016     }
12017
12018     /**
12019      * word len
12020      */
12021
12022     uint pw_min = PW_MIN;
12023     uint pw_max = PW_MAX;
12024
12025     switch (hash_mode)
12026     {
12027       case   125: if (pw_max > 32) pw_max = 32;
12028                   break;
12029       case   400: if (pw_max > 40) pw_max = 40;
12030                   break;
12031       case   500: if (pw_max > 16) pw_max = 16;
12032                   break;
12033       case  1500: if (pw_max >  8) pw_max =  8;
12034                   break;
12035       case  1600: if (pw_max > 16) pw_max = 16;
12036                   break;
12037       case  1800: if (pw_max > 16) pw_max = 16;
12038                   break;
12039       case  2100: if (pw_max > 16) pw_max = 16;
12040                   break;
12041       case  2500: if (pw_min <  8) pw_min =  8;
12042                   break;
12043       case  3000: if (pw_max >  7) pw_max =  7;
12044                   break;
12045       case  5200: if (pw_max > 24) pw_max = 24;
12046                   break;
12047       case  5800: if (pw_max > 16) pw_max = 16;
12048                   break;
12049       case  6300: if (pw_max > 16) pw_max = 16;
12050                   break;
12051       case  7400: if (pw_max > 16) pw_max = 16;
12052                   break;
12053       case  7700: if (pw_max >  8) pw_max =  8;
12054                   break;
12055       case  7900: if (pw_max > 48) pw_max = 48;
12056                   break;
12057       case  8500: if (pw_max >  8) pw_max =  8;
12058                   break;
12059       case  8600: if (pw_max > 16) pw_max = 16;
12060                   break;
12061       case  9710: pw_min = 5;
12062                   pw_max = 5;
12063                   break;
12064       case  9810: pw_min = 5;
12065                   pw_max = 5;
12066                   break;
12067       case 10410: pw_min = 5;
12068                   pw_max = 5;
12069                   break;
12070       case 10300: if (pw_max <  3) pw_min =  3;
12071                   if (pw_max > 40) pw_max = 40;
12072                   break;
12073       case 10500: if (pw_max <  3) pw_min =  3;
12074                   if (pw_max > 40) pw_max = 40;
12075                   break;
12076       case 10700: if (pw_max > 16) pw_max = 16;
12077                   break;
12078       case 11300: if (pw_max > 40) pw_max = 40;
12079                   break;
12080       case 11600: if (pw_max > 32) pw_max = 32;
12081                   break;
12082       case 12500: if (pw_max > 20) pw_max = 20;
12083                   break;
12084       case 12800: if (pw_max > 24) pw_max = 24;
12085                   break;
12086     }
12087
12088     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12089     {
12090       switch (attack_kern)
12091       {
12092         case ATTACK_KERN_STRAIGHT:  if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12093                                     break;
12094         case ATTACK_KERN_COMBI:     if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12095                                     break;
12096       }
12097     }
12098
12099     /**
12100      * charsets : keep them together for more easy maintainnce
12101      */
12102
12103     cs_t mp_sys[6] = { { { 0 }, 0 } };
12104     cs_t mp_usr[4] = { { { 0 }, 0 } };
12105
12106     mp_setup_sys (mp_sys);
12107
12108     if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
12109     if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
12110     if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
12111     if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
12112
12113     /**
12114      * load hashes, part I: find input mode, count hashes
12115      */
12116
12117     uint hashlist_mode   = 0;
12118     uint hashlist_format = HLFMT_HASHCAT;
12119
12120     uint hashes_avail = 0;
12121
12122     if ((benchmark == 0) && (stdout_flag == 0))
12123     {
12124       struct stat f;
12125
12126       hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
12127
12128       if ((hash_mode == 2500) ||
12129           (hash_mode == 5200) ||
12130           ((hash_mode >=  6200) && (hash_mode <=  6299)) ||
12131           ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
12132           (hash_mode == 9000))
12133       {
12134         hashlist_mode = HL_MODE_ARG;
12135
12136         char *hashfile = myargv[optind];
12137
12138         data.hashfile = hashfile;
12139
12140         logfile_top_var_string ("target", hashfile);
12141       }
12142
12143       if (hashlist_mode == HL_MODE_ARG)
12144       {
12145         if (hash_mode == 2500)
12146         {
12147           struct stat st;
12148
12149           if (stat (data.hashfile, &st) == -1)
12150           {
12151             log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
12152
12153             return -1;
12154           }
12155
12156           hashes_avail = st.st_size / sizeof (hccap_t);
12157         }
12158         else
12159         {
12160           hashes_avail = 1;
12161         }
12162       }
12163       else if (hashlist_mode == HL_MODE_FILE)
12164       {
12165         char *hashfile = myargv[optind];
12166
12167         data.hashfile = hashfile;
12168
12169         logfile_top_var_string ("target", hashfile);
12170
12171         FILE *fp = NULL;
12172
12173         if ((fp = fopen (hashfile, "rb")) == NULL)
12174         {
12175           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12176
12177           return -1;
12178         }
12179
12180         if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
12181
12182         hashes_avail = count_lines (fp);
12183
12184         rewind (fp);
12185
12186         if (hashes_avail == 0)
12187         {
12188           log_error ("ERROR: hashfile is empty or corrupt");
12189
12190           fclose (fp);
12191
12192           return -1;
12193         }
12194
12195         hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
12196
12197         if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
12198         {
12199           log_error ("ERROR: remove not supported in native hashfile-format mode");
12200
12201           fclose (fp);
12202
12203           return -1;
12204         }
12205
12206         fclose (fp);
12207       }
12208     }
12209     else
12210     {
12211       hashlist_mode = HL_MODE_ARG;
12212
12213       hashes_avail = 1;
12214     }
12215
12216     if (hash_mode == 3000) hashes_avail *= 2;
12217
12218     data.hashlist_mode   = hashlist_mode;
12219     data.hashlist_format = hashlist_format;
12220
12221     logfile_top_uint (hashlist_mode);
12222     logfile_top_uint (hashlist_format);
12223
12224     /**
12225      * load hashes, part II: allocate required memory, set pointers
12226      */
12227
12228     hash_t *hashes_buf  = NULL;
12229     void   *digests_buf = NULL;
12230     salt_t *salts_buf   = NULL;
12231     void   *esalts_buf  = NULL;
12232
12233     hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
12234
12235     digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
12236
12237     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12238     {
12239       u32 hash_pos;
12240
12241       for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12242       {
12243         hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
12244
12245         hashes_buf[hash_pos].hash_info = hash_info;
12246
12247         if (username && (remove || show || left))
12248         {
12249           hash_info->user = (user_t*) mymalloc (sizeof (user_t));
12250         }
12251
12252         if (benchmark)
12253         {
12254           hash_info->orighash = (char *) mymalloc (256);
12255         }
12256       }
12257     }
12258
12259     if (isSalted)
12260     {
12261       salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12262
12263       if (esalt_size)
12264       {
12265         esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
12266       }
12267     }
12268     else
12269     {
12270       salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
12271     }
12272
12273     for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12274     {
12275       hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
12276
12277       if (isSalted)
12278       {
12279         hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
12280
12281         if (esalt_size)
12282         {
12283           hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
12284         }
12285       }
12286       else
12287       {
12288         hashes_buf[hash_pos].salt = &salts_buf[0];
12289       }
12290     }
12291
12292     /**
12293      * load hashes, part III: parse hashes or generate them if benchmark
12294      */
12295
12296     uint hashes_cnt = 0;
12297
12298     if (benchmark == 0)
12299     {
12300       if (keyspace == 1)
12301       {
12302         // useless to read hash file for keyspace, cheat a little bit w/ optind
12303       }
12304       else if (stdout_flag == 1)
12305       {
12306         // useless to read hash file for stdout, cheat a little bit w/ optind
12307       }
12308       else if (hashes_avail == 0)
12309       {
12310       }
12311       else if (hashlist_mode == HL_MODE_ARG)
12312       {
12313         char *input_buf = myargv[optind];
12314
12315         uint input_len = strlen (input_buf);
12316
12317         logfile_top_var_string ("target", input_buf);
12318
12319         char *hash_buf = NULL;
12320         int   hash_len = 0;
12321
12322         hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
12323
12324         bool hash_fmt_error = 0;
12325
12326         if (hash_len < 1)     hash_fmt_error = 1;
12327         if (hash_buf == NULL) hash_fmt_error = 1;
12328
12329         if (hash_fmt_error)
12330         {
12331           log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12332         }
12333         else
12334         {
12335           if (opts_type & OPTS_TYPE_HASH_COPY)
12336           {
12337             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12338
12339             hash_info_tmp->orighash = mystrdup (hash_buf);
12340           }
12341
12342           if (isSalted)
12343           {
12344             memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12345           }
12346
12347           int parser_status = PARSER_OK;
12348
12349           if (hash_mode == 2500)
12350           {
12351             if (hash_len == 0)
12352             {
12353               log_error ("ERROR: hccap file not specified");
12354
12355               return -1;
12356             }
12357
12358             hashlist_mode = HL_MODE_FILE;
12359
12360             data.hashlist_mode = hashlist_mode;
12361
12362             FILE *fp = fopen (hash_buf, "rb");
12363
12364             if (fp == NULL)
12365             {
12366               log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12367
12368               return -1;
12369             }
12370
12371             if (hashes_avail < 1)
12372             {
12373               log_error ("ERROR: hccap file is empty or corrupt");
12374
12375               fclose (fp);
12376
12377               return -1;
12378             }
12379
12380             uint hccap_size = sizeof (hccap_t);
12381
12382             char *in = (char *) mymalloc (hccap_size);
12383
12384             while (!feof (fp))
12385             {
12386               int n = fread (in, hccap_size, 1, fp);
12387
12388               if (n != 1)
12389               {
12390                 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12391
12392                 break;
12393               }
12394
12395               parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12396
12397               if (parser_status != PARSER_OK)
12398               {
12399                 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12400
12401                 continue;
12402               }
12403
12404               // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12405
12406               if ((show == 1) || (left == 1))
12407               {
12408                 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12409
12410                 char *salt_ptr = (char *) tmp_salt->salt_buf;
12411
12412                 int cur_pos = tmp_salt->salt_len;
12413                 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12414
12415                 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12416
12417                 // do the appending task
12418
12419                 snprintf (salt_ptr + cur_pos,
12420                           rem_len,
12421                           ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12422                           wpa->orig_mac1[0],
12423                           wpa->orig_mac1[1],
12424                           wpa->orig_mac1[2],
12425                           wpa->orig_mac1[3],
12426                           wpa->orig_mac1[4],
12427                           wpa->orig_mac1[5],
12428                           wpa->orig_mac2[0],
12429                           wpa->orig_mac2[1],
12430                           wpa->orig_mac2[2],
12431                           wpa->orig_mac2[3],
12432                           wpa->orig_mac2[4],
12433                           wpa->orig_mac2[5]);
12434
12435                 // memset () the remaining part of the salt
12436
12437                 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12438                 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12439
12440                 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12441
12442                 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12443               }
12444
12445               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);
12446               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);
12447
12448               hashes_cnt++;
12449             }
12450
12451             fclose (fp);
12452
12453             myfree (in);
12454           }
12455           else if (hash_mode == 3000)
12456           {
12457             if (hash_len == 32)
12458             {
12459               parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12460
12461               hash_t *lm_hash_left = NULL;
12462
12463               if (parser_status == PARSER_OK)
12464               {
12465                 lm_hash_left = &hashes_buf[hashes_cnt];
12466
12467                 hashes_cnt++;
12468               }
12469               else
12470               {
12471                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12472               }
12473
12474               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12475
12476               hash_t *lm_hash_right = NULL;
12477
12478               if (parser_status == PARSER_OK)
12479               {
12480                 lm_hash_right = &hashes_buf[hashes_cnt];
12481
12482                 hashes_cnt++;
12483               }
12484               else
12485               {
12486                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12487               }
12488
12489               // show / left
12490
12491               if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12492               {
12493                 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);
12494                 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);
12495               }
12496             }
12497             else
12498             {
12499               parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12500
12501               if (parser_status == PARSER_OK)
12502               {
12503                 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12504                 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12505               }
12506
12507               if (parser_status == PARSER_OK)
12508               {
12509                 hashes_cnt++;
12510               }
12511               else
12512               {
12513                 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12514               }
12515             }
12516           }
12517           else
12518           {
12519             parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12520
12521             if (parser_status == PARSER_OK)
12522             {
12523               if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12524               if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12525             }
12526
12527             if (parser_status == PARSER_OK)
12528             {
12529               hashes_cnt++;
12530             }
12531             else
12532             {
12533               log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12534             }
12535           }
12536         }
12537       }
12538       else if (hashlist_mode == HL_MODE_FILE)
12539       {
12540         char *hashfile = data.hashfile;
12541
12542         FILE *fp;
12543
12544         if ((fp = fopen (hashfile, "rb")) == NULL)
12545         {
12546           log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12547
12548           return -1;
12549         }
12550
12551         uint line_num = 0;
12552
12553         char *line_buf = (char *) mymalloc (HCBUFSIZ);
12554
12555         while (!feof (fp))
12556         {
12557           line_num++;
12558
12559           int line_len = fgetl (fp, line_buf);
12560
12561           if (line_len == 0) continue;
12562
12563           char *hash_buf = NULL;
12564           int   hash_len = 0;
12565
12566           hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12567
12568           bool hash_fmt_error = 0;
12569
12570           if (hash_len < 1)     hash_fmt_error = 1;
12571           if (hash_buf == NULL) hash_fmt_error = 1;
12572
12573           if (hash_fmt_error)
12574           {
12575             log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12576
12577             continue;
12578           }
12579
12580           if (username)
12581           {
12582             char *user_buf = NULL;
12583             int   user_len = 0;
12584
12585             hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12586
12587             if (remove || show)
12588             {
12589               user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12590
12591               *user = (user_t *) mymalloc (sizeof (user_t));
12592
12593               user_t *user_ptr = *user;
12594
12595               if (user_buf != NULL)
12596               {
12597                 user_ptr->user_name = mystrdup (user_buf);
12598               }
12599               else
12600               {
12601                 user_ptr->user_name = mystrdup ("");
12602               }
12603
12604               user_ptr->user_len = user_len;
12605             }
12606           }
12607
12608           if (opts_type & OPTS_TYPE_HASH_COPY)
12609           {
12610             hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12611
12612             hash_info_tmp->orighash = mystrdup (hash_buf);
12613           }
12614
12615           if (isSalted)
12616           {
12617             memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12618           }
12619
12620           if (hash_mode == 3000)
12621           {
12622             if (hash_len == 32)
12623             {
12624               int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12625
12626               if (parser_status < PARSER_GLOBAL_ZERO)
12627               {
12628                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12629
12630                 continue;
12631               }
12632
12633               hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12634
12635               hashes_cnt++;
12636
12637               parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12638
12639               if (parser_status < PARSER_GLOBAL_ZERO)
12640               {
12641                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12642
12643                 continue;
12644               }
12645
12646               hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12647
12648               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);
12649
12650               hashes_cnt++;
12651
12652               // show / left
12653
12654               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);
12655               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);
12656             }
12657             else
12658             {
12659               int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12660
12661               if (parser_status < PARSER_GLOBAL_ZERO)
12662               {
12663                 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12664
12665                 continue;
12666               }
12667
12668               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);
12669
12670               if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12671               if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12672
12673               hashes_cnt++;
12674             }
12675           }
12676           else
12677           {
12678             int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12679
12680             if (parser_status < PARSER_GLOBAL_ZERO)
12681             {
12682               log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12683
12684               continue;
12685             }
12686
12687             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);
12688
12689             if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12690             if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12691
12692             hashes_cnt++;
12693           }
12694         }
12695
12696         myfree (line_buf);
12697
12698         fclose (fp);
12699
12700         if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12701
12702         if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12703       }
12704     }
12705     else
12706     {
12707       if (isSalted)
12708       {
12709         hashes_buf[0].salt->salt_len = 8;
12710
12711         // special salt handling
12712
12713         switch (hash_mode)
12714         {
12715           case  1500: hashes_buf[0].salt->salt_len    = 2;
12716                       hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12717                       break;
12718           case  1731: hashes_buf[0].salt->salt_len = 4;
12719                       break;
12720           case  2410: hashes_buf[0].salt->salt_len = 4;
12721                       break;
12722           case  2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12723                       break;
12724           case  3100: hashes_buf[0].salt->salt_len = 1;
12725                       break;
12726           case  5000: hashes_buf[0].salt->keccak_mdlen = 32;
12727                       break;
12728           case  5800: hashes_buf[0].salt->salt_len = 16;
12729                       break;
12730           case  6800: hashes_buf[0].salt->salt_len = 32;
12731                       break;
12732           case  8400: hashes_buf[0].salt->salt_len = 40;
12733                       break;
12734           case  8800: hashes_buf[0].salt->salt_len = 16;
12735                       break;
12736           case  8900: hashes_buf[0].salt->salt_len = 16;
12737                       hashes_buf[0].salt->scrypt_N = 1024;
12738                       hashes_buf[0].salt->scrypt_r = 1;
12739                       hashes_buf[0].salt->scrypt_p = 1;
12740                       break;
12741           case  9100: hashes_buf[0].salt->salt_len = 16;
12742                       break;
12743           case  9300: hashes_buf[0].salt->salt_len = 14;
12744                       hashes_buf[0].salt->scrypt_N = 16384;
12745                       hashes_buf[0].salt->scrypt_r = 1;
12746                       hashes_buf[0].salt->scrypt_p = 1;
12747                       break;
12748           case  9400: hashes_buf[0].salt->salt_len = 16;
12749                       break;
12750           case  9500: hashes_buf[0].salt->salt_len = 16;
12751                       break;
12752           case  9600: hashes_buf[0].salt->salt_len = 16;
12753                       break;
12754           case  9700: hashes_buf[0].salt->salt_len = 16;
12755                       break;
12756           case  9710: hashes_buf[0].salt->salt_len = 16;
12757                       break;
12758           case  9720: hashes_buf[0].salt->salt_len = 16;
12759                       break;
12760           case  9800: hashes_buf[0].salt->salt_len = 16;
12761                       break;
12762           case  9810: hashes_buf[0].salt->salt_len = 16;
12763                       break;
12764           case  9820: hashes_buf[0].salt->salt_len = 16;
12765                       break;
12766           case 10300: hashes_buf[0].salt->salt_len = 12;
12767                       break;
12768           case 11500: hashes_buf[0].salt->salt_len = 4;
12769                       break;
12770           case 11600: hashes_buf[0].salt->salt_len = 4;
12771                       break;
12772           case 12400: hashes_buf[0].salt->salt_len = 4;
12773                       break;
12774           case 12500: hashes_buf[0].salt->salt_len = 8;
12775                       break;
12776           case 12600: hashes_buf[0].salt->salt_len = 64;
12777                       break;
12778         }
12779
12780         // special esalt handling
12781
12782         switch (hash_mode)
12783         {
12784           case  2500: ((wpa_t *)     hashes_buf[0].esalt)->eapol_size   = 128;
12785                       break;
12786           case  5300: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12787                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12788                       break;
12789           case  5400: ((ikepsk_t *)  hashes_buf[0].esalt)->nr_len       = 1;
12790                       ((ikepsk_t *)  hashes_buf[0].esalt)->msg_len      = 1;
12791                       break;
12792           case  5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12793                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12794                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12795                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12796                       break;
12797           case  5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len     = 1;
12798                       ((netntlm_t *) hashes_buf[0].esalt)->domain_len   = 1;
12799                       ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12800                       ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12801                       break;
12802           case  7300: ((rakp_t *)    hashes_buf[0].esalt)->salt_len     = 32;
12803                       break;
12804           case 10400: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12805                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12806                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12807                       break;
12808           case 10410: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12809                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12810                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12811                       break;
12812           case 10420: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12813                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12814                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12815                       break;
12816           case 10500: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12817                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 32;
12818                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 32;
12819                       break;
12820           case 10600: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12821                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12822                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12823                       break;
12824           case 10700: ((pdf_t *)     hashes_buf[0].esalt)->id_len       = 16;
12825                       ((pdf_t *)     hashes_buf[0].esalt)->o_len        = 127;
12826                       ((pdf_t *)     hashes_buf[0].esalt)->u_len        = 127;
12827                       break;
12828           case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len      = 16;
12829                       ((seven_zip_t *) hashes_buf[0].esalt)->data_len    = 112;
12830                       ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12831                       break;
12832           case 13400: ((keepass_t *) hashes_buf[0].esalt)->version      = 2;
12833                       break;
12834           case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len     = 113;
12835                       break;
12836           case 13600: ((zip2_t *)    hashes_buf[0].esalt)->salt_len     = 16;
12837                       ((zip2_t *)    hashes_buf[0].esalt)->data_len     = 32;
12838                       ((zip2_t *)    hashes_buf[0].esalt)->mode         = 3;
12839                       break;
12840         }
12841       }
12842
12843       // set hashfile
12844
12845       switch (hash_mode)
12846       {
12847         case 5200:  data.hashfile = mystrdup ("hashcat.psafe3");
12848                     break;
12849         case 5300:  data.hashfile = mystrdup ("hashcat.ikemd5");
12850                     break;
12851         case 5400:  data.hashfile = mystrdup ("hashcat.ikesha1");
12852                     break;
12853         case 6211:  data.hashfile = mystrdup ("hashcat.tc");
12854                     break;
12855         case 6212:  data.hashfile = mystrdup ("hashcat.tc");
12856                     break;
12857         case 6213:  data.hashfile = mystrdup ("hashcat.tc");
12858                     break;
12859         case 6221:  data.hashfile = mystrdup ("hashcat.tc");
12860                     break;
12861         case 6222:  data.hashfile = mystrdup ("hashcat.tc");
12862                     break;
12863         case 6223:  data.hashfile = mystrdup ("hashcat.tc");
12864                     break;
12865         case 6231:  data.hashfile = mystrdup ("hashcat.tc");
12866                     break;
12867         case 6232:  data.hashfile = mystrdup ("hashcat.tc");
12868                     break;
12869         case 6233:  data.hashfile = mystrdup ("hashcat.tc");
12870                     break;
12871         case 6241:  data.hashfile = mystrdup ("hashcat.tc");
12872                     break;
12873         case 6242:  data.hashfile = mystrdup ("hashcat.tc");
12874                     break;
12875         case 6243:  data.hashfile = mystrdup ("hashcat.tc");
12876                     break;
12877         case 6600:  data.hashfile = mystrdup ("hashcat.agilekey");
12878                     break;
12879         case 8200:  data.hashfile = mystrdup ("hashcat.cloudkey");
12880                     break;
12881         case 9000:  data.hashfile = mystrdup ("hashcat.psafe2");
12882                     break;
12883         case 13711: data.hashfile = mystrdup ("hashcat.vc");
12884                     break;
12885         case 13712: data.hashfile = mystrdup ("hashcat.vc");
12886                     break;
12887         case 13713: data.hashfile = mystrdup ("hashcat.vc");
12888                     break;
12889         case 13721: data.hashfile = mystrdup ("hashcat.vc");
12890                     break;
12891         case 13722: data.hashfile = mystrdup ("hashcat.vc");
12892                     break;
12893         case 13723: data.hashfile = mystrdup ("hashcat.vc");
12894                     break;
12895         case 13731: data.hashfile = mystrdup ("hashcat.vc");
12896                     break;
12897         case 13732: data.hashfile = mystrdup ("hashcat.vc");
12898                     break;
12899         case 13733: data.hashfile = mystrdup ("hashcat.vc");
12900                     break;
12901         case 13741: data.hashfile = mystrdup ("hashcat.vc");
12902                     break;
12903         case 13742: data.hashfile = mystrdup ("hashcat.vc");
12904                     break;
12905         case 13743: data.hashfile = mystrdup ("hashcat.vc");
12906                     break;
12907         case 13751: data.hashfile = mystrdup ("hashcat.vc");
12908                     break;
12909         case 13752: data.hashfile = mystrdup ("hashcat.vc");
12910                     break;
12911         case 13753: data.hashfile = mystrdup ("hashcat.vc");
12912                     break;
12913         case 13761: data.hashfile = mystrdup ("hashcat.vc");
12914                     break;
12915         case 13762: data.hashfile = mystrdup ("hashcat.vc");
12916                     break;
12917         case 13763: data.hashfile = mystrdup ("hashcat.vc");
12918                     break;
12919       }
12920
12921       // set default iterations
12922
12923       switch (hash_mode)
12924       {
12925         case   400:  hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12926                      break;
12927         case   500:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12928                      break;
12929         case   501:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12930                      break;
12931         case  1600:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12932                      break;
12933         case  1800:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12934                      break;
12935         case  2100:  hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12936                      break;
12937         case  2500:  hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12938                      break;
12939         case  3200:  hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12940                      break;
12941         case  5200:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12942                      break;
12943         case  5800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12944                      break;
12945         case  6211:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12946                      break;
12947         case  6212:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12948                      break;
12949         case  6213:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12950                      break;
12951         case  6221:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12952                      break;
12953         case  6222:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12954                      break;
12955         case  6223:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12956                      break;
12957         case  6231:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12958                      break;
12959         case  6232:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12960                      break;
12961         case  6233:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12962                      break;
12963         case  6241:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12964                      break;
12965         case  6242:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12966                      break;
12967         case  6243:  hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12968                      break;
12969         case  6300:  hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12970                      break;
12971         case  6400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12972                      break;
12973         case  6500:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12974                      break;
12975         case  6700:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12976                      break;
12977         case  6600:  hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12978                      break;
12979         case  6800:  hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12980                      break;
12981         case  7100:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12982                      break;
12983         case  7200:  hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12984                      break;
12985         case  7400:  hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12986                      break;
12987         case  7900:  hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12988                      break;
12989         case  8200:  hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12990                      break;
12991         case  8300:  hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12992                      break;
12993         case  8800:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12994                      break;
12995         case  8900:  hashes_buf[0].salt->salt_iter = 1;
12996                      break;
12997         case  9000:  hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12998                      break;
12999         case  9100:  hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
13000                      break;
13001         case  9200:  hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
13002                      break;
13003         case  9300:  hashes_buf[0].salt->salt_iter = 1;
13004                      break;
13005         case  9400:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
13006                      break;
13007         case  9500:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
13008                      break;
13009         case  9600:  hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
13010                      break;
13011         case 10000:  hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
13012                      break;
13013         case 10300:  hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
13014                      break;
13015         case 10500:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
13016                      break;
13017         case 10700:  hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
13018                      break;
13019         case 10900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
13020                      break;
13021         case 11300:  hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
13022                      break;
13023         case 11600:  hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
13024                      break;
13025         case 11900:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
13026                      break;
13027         case 12000:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
13028                      break;
13029         case 12100:  hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
13030                      break;
13031         case 12200:  hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
13032                      break;
13033         case 12300:  hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
13034                      break;
13035         case 12400:  hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
13036                      break;
13037         case 12500:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
13038                      break;
13039         case 12700:  hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
13040                      break;
13041         case 12800:  hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
13042                      break;
13043         case 12900:  hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
13044                      break;
13045         case 13000:  hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
13046                      break;
13047         case 13200:  hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
13048                      break;
13049         case 13400:  hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
13050                      break;
13051         case 13600:  hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
13052                      break;
13053         case 13711:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13054                      break;
13055         case 13712:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13056                      break;
13057         case 13713:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13058                      break;
13059         case 13721:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13060                      break;
13061         case 13722:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13062                      break;
13063         case 13723:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13064                      break;
13065         case 13731:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13066                      break;
13067         case 13732:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13068                      break;
13069         case 13733:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13070                      break;
13071         case 13741:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13072                      break;
13073         case 13742:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13074                      break;
13075         case 13743:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13076                      break;
13077         case 13751:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13078                      break;
13079         case 13752:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13080                      break;
13081         case 13753:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13082                      break;
13083         case 13761:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13084                      break;
13085         case 13762:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13086                      break;
13087         case 13763:  hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13088                      break;
13089       }
13090
13091       hashes_cnt = 1;
13092     }
13093
13094     if (show == 1 || left == 1)
13095     {
13096       for (uint i = 0; i < pot_cnt; i++)
13097       {
13098         pot_t *pot_ptr = &pot[i];
13099
13100         hash_t *hashes_buf = &pot_ptr->hash;
13101
13102         local_free (hashes_buf->digest);
13103
13104         if (isSalted)
13105         {
13106           local_free (hashes_buf->salt);
13107         }
13108       }
13109
13110       local_free (pot);
13111
13112       if (data.quiet == 0) log_info_nn ("");
13113
13114       return 0;
13115     }
13116
13117     if ((keyspace == 0) && (stdout_flag == 0))
13118     {
13119       if (hashes_cnt == 0)
13120       {
13121         log_error ("ERROR: No hashes loaded");
13122
13123         return -1;
13124       }
13125     }
13126
13127     /**
13128      * Sanity check for hashfile vs outfile (should not point to the same physical file)
13129      */
13130
13131     if (data.outfile != NULL)
13132     {
13133       if (data.hashfile != NULL)
13134       {
13135         #ifdef _POSIX
13136         struct stat tmpstat_outfile;
13137         struct stat tmpstat_hashfile;
13138         #endif
13139
13140         #ifdef _WIN
13141         struct stat64 tmpstat_outfile;
13142         struct stat64 tmpstat_hashfile;
13143         #endif
13144
13145         FILE *tmp_outfile_fp = fopen (data.outfile, "r");
13146
13147         if (tmp_outfile_fp)
13148         {
13149           #ifdef _POSIX
13150           fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
13151           #endif
13152
13153           #ifdef _WIN
13154           _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
13155           #endif
13156
13157           fclose (tmp_outfile_fp);
13158         }
13159
13160         FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
13161
13162         if (tmp_hashfile_fp)
13163         {
13164           #ifdef _POSIX
13165           fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13166           #endif
13167
13168           #ifdef _WIN
13169           _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13170           #endif
13171
13172           fclose (tmp_hashfile_fp);
13173         }
13174
13175         if (tmp_outfile_fp && tmp_outfile_fp)
13176         {
13177           tmpstat_outfile.st_mode     = 0;
13178           tmpstat_outfile.st_nlink    = 0;
13179           tmpstat_outfile.st_uid      = 0;
13180           tmpstat_outfile.st_gid      = 0;
13181           tmpstat_outfile.st_rdev     = 0;
13182           tmpstat_outfile.st_atime    = 0;
13183
13184           tmpstat_hashfile.st_mode    = 0;
13185           tmpstat_hashfile.st_nlink   = 0;
13186           tmpstat_hashfile.st_uid     = 0;
13187           tmpstat_hashfile.st_gid     = 0;
13188           tmpstat_hashfile.st_rdev    = 0;
13189           tmpstat_hashfile.st_atime   = 0;
13190
13191           #ifdef _POSIX
13192           tmpstat_outfile.st_blksize  = 0;
13193           tmpstat_outfile.st_blocks   = 0;
13194
13195           tmpstat_hashfile.st_blksize = 0;
13196           tmpstat_hashfile.st_blocks  = 0;
13197           #endif
13198
13199           #ifdef _POSIX
13200           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
13201           {
13202             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13203
13204             return -1;
13205           }
13206           #endif
13207
13208           #ifdef _WIN
13209           if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
13210           {
13211             log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13212
13213             return -1;
13214           }
13215           #endif
13216         }
13217       }
13218     }
13219
13220     /**
13221      * Remove duplicates
13222      */
13223
13224     if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
13225
13226     if (isSalted)
13227     {
13228       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13229     }
13230     else
13231     {
13232       qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13233     }
13234
13235     uint hashes_cnt_orig = hashes_cnt;
13236
13237     hashes_cnt = 1;
13238
13239     for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
13240     {
13241       if (isSalted)
13242       {
13243         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
13244         {
13245           if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13246         }
13247       }
13248       else
13249       {
13250         if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13251       }
13252
13253       if (hashes_pos > hashes_cnt)
13254       {
13255         memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
13256       }
13257
13258       hashes_cnt++;
13259     }
13260
13261     /**
13262      * Potfile removes
13263      */
13264
13265     uint potfile_remove_cracks = 0;
13266
13267     if (potfile_disable == 0)
13268     {
13269       hash_t hash_buf;
13270
13271       hash_buf.digest    = mymalloc (dgst_size);
13272       hash_buf.salt      = NULL;
13273       hash_buf.esalt     = NULL;
13274       hash_buf.hash_info = NULL;
13275       hash_buf.cracked   = 0;
13276
13277       if (isSalted)
13278       {
13279         hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
13280       }
13281
13282       if (esalt_size)
13283       {
13284         hash_buf.esalt = mymalloc (esalt_size);
13285       }
13286
13287       if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
13288
13289       // no solution for these special hash types (for instane because they use hashfile in output etc)
13290       if ((hash_mode != 5200) &&
13291           !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
13292           !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
13293           (hash_mode != 9000))
13294       {
13295         FILE *fp = fopen (potfile, "rb");
13296
13297         if (fp != NULL)
13298         {
13299           char *line_buf = (char *) mymalloc (HCBUFSIZ);
13300
13301           // to be safe work with a copy (because of line_len loop, i etc)
13302           // moved up here because it's easier to handle continue case
13303           // it's just 64kb
13304
13305           char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
13306
13307           while (!feof (fp))
13308           {
13309             char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
13310
13311             if (ptr == NULL) break;
13312
13313             int line_len = strlen (line_buf);
13314
13315             if (line_len == 0) continue;
13316
13317             int iter = MAX_CUT_TRIES;
13318
13319             for (int i = line_len - 1; i && iter; i--, line_len--)
13320             {
13321               if (line_buf[i] != ':') continue;
13322
13323               if (isSalted)
13324               {
13325                 memset (hash_buf.salt, 0, sizeof (salt_t));
13326               }
13327
13328               hash_t *found = NULL;
13329
13330               if (hash_mode == 6800)
13331               {
13332                 if (i < 64) // 64 = 16 * uint in salt_buf[]
13333                 {
13334                   // manipulate salt_buf
13335                   memcpy (hash_buf.salt->salt_buf, line_buf, i);
13336
13337                   hash_buf.salt->salt_len = i;
13338
13339                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13340                 }
13341               }
13342               else if (hash_mode == 2500)
13343               {
13344                 if (i < 64) // 64 = 16 * uint in salt_buf[]
13345                 {
13346                   // here we have in line_buf: ESSID:MAC1:MAC2   (without the plain)
13347                   // manipulate salt_buf
13348
13349                   memset (line_buf_cpy, 0, HCBUFSIZ);
13350                   memcpy (line_buf_cpy, line_buf, i);
13351
13352                   char *mac2_pos = strrchr (line_buf_cpy, ':');
13353
13354                   if (mac2_pos == NULL) continue;
13355
13356                   mac2_pos[0] = 0;
13357                   mac2_pos++;
13358
13359                   if (strlen (mac2_pos) != 12) continue;
13360
13361                   char *mac1_pos = strrchr (line_buf_cpy, ':');
13362
13363                   if (mac1_pos == NULL) continue;
13364
13365                   mac1_pos[0] = 0;
13366                   mac1_pos++;
13367
13368                   if (strlen (mac1_pos) != 12) continue;
13369
13370                   uint essid_length = mac1_pos - line_buf_cpy - 1;
13371
13372                   // here we need the ESSID
13373                   memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13374
13375                   hash_buf.salt->salt_len = essid_length;
13376
13377                   found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13378
13379                   if (found)
13380                   {
13381                     wpa_t *wpa = (wpa_t *) found->esalt;
13382
13383                     // compare hex string(s) vs binary MAC address(es)
13384
13385                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13386                     {
13387                       if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13388                       {
13389                         found = NULL;
13390
13391                         break;
13392                       }
13393                     }
13394
13395                     // early skip ;)
13396                     if (!found) continue;
13397
13398                     for (uint i = 0, j = 0; i < 6; i++, j += 2)
13399                     {
13400                       if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13401                       {
13402                         found = NULL;
13403
13404                         break;
13405                       }
13406                     }
13407                   }
13408                 }
13409               }
13410               else
13411               {
13412                 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13413
13414                 if (parser_status == PARSER_OK)
13415                 {
13416                   if (isSalted)
13417                   {
13418                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13419                   }
13420                   else
13421                   {
13422                     found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13423                   }
13424                 }
13425               }
13426
13427               if (found == NULL) continue;
13428
13429               if (!found->cracked) potfile_remove_cracks++;
13430
13431               found->cracked = 1;
13432
13433               if (found) break;
13434
13435               iter--;
13436             }
13437           }
13438
13439           myfree (line_buf_cpy);
13440
13441           myfree (line_buf);
13442
13443           fclose (fp);
13444         }
13445       }
13446
13447       if (esalt_size)
13448       {
13449         local_free (hash_buf.esalt);
13450       }
13451
13452       if (isSalted)
13453       {
13454         local_free (hash_buf.salt);
13455       }
13456
13457       local_free (hash_buf.digest);
13458     }
13459
13460     /**
13461      * Now generate all the buffers required for later
13462      */
13463
13464     void   *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13465
13466     salt_t *salts_buf_new  = NULL;
13467     void   *esalts_buf_new = NULL;
13468
13469     if (isSalted)
13470     {
13471       salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13472
13473       if (esalt_size)
13474       {
13475         esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13476       }
13477     }
13478     else
13479     {
13480       salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13481     }
13482
13483     if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13484
13485     uint digests_cnt  = hashes_cnt;
13486     uint digests_done = 0;
13487
13488     size_t size_digests = digests_cnt * dgst_size;
13489     size_t size_shown   = digests_cnt * sizeof (uint);
13490
13491     uint *digests_shown     = (uint *) mymalloc (size_shown);
13492     uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13493
13494     uint salts_cnt   = 0;
13495     uint salts_done  = 0;
13496
13497     hashinfo_t **hash_info = NULL;
13498
13499     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13500     {
13501       hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13502
13503       if (username && (remove || show))
13504       {
13505         uint user_pos;
13506
13507         for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13508         {
13509           hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13510
13511           hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13512         }
13513       }
13514     }
13515
13516     uint *salts_shown = (uint *) mymalloc (size_shown);
13517
13518     salt_t *salt_buf;
13519
13520     {
13521       // copied from inner loop
13522
13523       salt_buf = &salts_buf_new[salts_cnt];
13524
13525       memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13526
13527       if (esalt_size)
13528       {
13529         memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13530       }
13531
13532       salt_buf->digests_cnt    = 0;
13533       salt_buf->digests_done   = 0;
13534       salt_buf->digests_offset = 0;
13535
13536       salts_cnt++;
13537     }
13538
13539     if (hashes_buf[0].cracked == 1)
13540     {
13541       digests_shown[0] = 1;
13542
13543       digests_done++;
13544
13545       salt_buf->digests_done++;
13546     }
13547
13548     salt_buf->digests_cnt++;
13549
13550     memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13551
13552     if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13553     {
13554       hash_info[0] = hashes_buf[0].hash_info;
13555     }
13556
13557     // copy from inner loop
13558
13559     for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13560     {
13561       if (isSalted)
13562       {
13563         if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13564         {
13565           salt_buf = &salts_buf_new[salts_cnt];
13566
13567           memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13568
13569           if (esalt_size)
13570           {
13571             memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13572           }
13573
13574           salt_buf->digests_cnt    = 0;
13575           salt_buf->digests_done   = 0;
13576           salt_buf->digests_offset = hashes_pos;
13577
13578           salts_cnt++;
13579         }
13580       }
13581
13582       if (hashes_buf[hashes_pos].cracked == 1)
13583       {
13584         digests_shown[hashes_pos] = 1;
13585
13586         digests_done++;
13587
13588         salt_buf->digests_done++;
13589       }
13590
13591       salt_buf->digests_cnt++;
13592
13593       memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13594
13595       if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13596       {
13597         hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13598       }
13599     }
13600
13601     for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13602     {
13603       salt_t *salt_buf = &salts_buf_new[salt_pos];
13604
13605       if (salt_buf->digests_done == salt_buf->digests_cnt)
13606       {
13607         salts_shown[salt_pos] = 1;
13608
13609         salts_done++;
13610       }
13611
13612       if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13613     }
13614
13615     local_free (digests_buf);
13616     local_free (salts_buf);
13617     local_free (esalts_buf);
13618
13619     digests_buf = digests_buf_new;
13620     salts_buf   = salts_buf_new;
13621     esalts_buf  = esalts_buf_new;
13622
13623     local_free (hashes_buf);
13624
13625     /**
13626      * special modification not set from parser
13627      */
13628
13629     switch (hash_mode)
13630     {
13631       case  6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13632       case  6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13633       case  6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13634       case  6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13635       case  6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13636       case  6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13637       case  6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13638       case  6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13639       case  6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13640       case  6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13641       case  6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13642       case  6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13643       case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13644       case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13645       case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13646       case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13647       case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13648       case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13649       case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13650       case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13651       case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13652       case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13653       case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13654       case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13655       case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13656       case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13657       case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13658       case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13659       case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13660       case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13661     }
13662
13663     if (truecrypt_keyfiles)
13664     {
13665       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13666
13667       char *keyfiles = strdup (truecrypt_keyfiles);
13668
13669       char *keyfile = strtok (keyfiles, ",");
13670
13671       do
13672       {
13673         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13674
13675       } while ((keyfile = strtok (NULL, ",")) != NULL);
13676
13677       free (keyfiles);
13678     }
13679
13680     if (veracrypt_keyfiles)
13681     {
13682       uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13683
13684       char *keyfiles = strdup (veracrypt_keyfiles);
13685
13686       char *keyfile = strtok (keyfiles, ",");
13687
13688       do
13689       {
13690         truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13691
13692       } while ((keyfile = strtok (NULL, ",")) != NULL);
13693
13694       free (keyfiles);
13695     }
13696
13697     data.digests_cnt        = digests_cnt;
13698     data.digests_done       = digests_done;
13699     data.digests_buf        = digests_buf;
13700     data.digests_shown      = digests_shown;
13701     data.digests_shown_tmp  = digests_shown_tmp;
13702
13703     data.salts_cnt          = salts_cnt;
13704     data.salts_done         = salts_done;
13705     data.salts_buf          = salts_buf;
13706     data.salts_shown        = salts_shown;
13707
13708     data.esalts_buf         = esalts_buf;
13709     data.hash_info          = hash_info;
13710
13711     /**
13712      * Automatic Optimizers
13713      */
13714
13715     if (salts_cnt == 1)
13716       opti_type |= OPTI_TYPE_SINGLE_SALT;
13717
13718     if (digests_cnt == 1)
13719       opti_type |= OPTI_TYPE_SINGLE_HASH;
13720
13721     if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13722       opti_type |= OPTI_TYPE_NOT_ITERATED;
13723
13724     if (attack_mode == ATTACK_MODE_BF)
13725       opti_type |= OPTI_TYPE_BRUTE_FORCE;
13726
13727     data.opti_type = opti_type;
13728
13729     if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13730     {
13731       if (opti_type & OPTI_TYPE_SINGLE_HASH)
13732       {
13733         if (opti_type & OPTI_TYPE_APPENDED_SALT)
13734         {
13735           if (opts_type & OPTS_TYPE_ST_ADD80)
13736           {
13737             opts_type &= ~OPTS_TYPE_ST_ADD80;
13738             opts_type |=  OPTS_TYPE_PT_ADD80;
13739           }
13740
13741           if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13742           {
13743             opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13744             opts_type |=  OPTS_TYPE_PT_ADDBITS14;
13745           }
13746
13747           if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13748           {
13749             opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13750             opts_type |=  OPTS_TYPE_PT_ADDBITS15;
13751           }
13752         }
13753       }
13754     }
13755
13756     /**
13757      * Some algorithm, like descrypt, can benefit from JIT compilation
13758      */
13759
13760     int force_jit_compilation = -1;
13761
13762     if (hash_mode == 8900)
13763     {
13764       force_jit_compilation = 8900;
13765     }
13766     else if (hash_mode == 9300)
13767     {
13768       force_jit_compilation = 8900;
13769     }
13770     else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13771     {
13772       force_jit_compilation = 1500;
13773     }
13774
13775     /**
13776      * generate bitmap tables
13777      */
13778
13779     const uint bitmap_shift1 = 5;
13780     const uint bitmap_shift2 = 13;
13781
13782     if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13783
13784     uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13785     uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13786     uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13787     uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13788     uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13789     uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13790     uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13791     uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13792
13793     uint bitmap_bits;
13794     uint bitmap_nums;
13795     uint bitmap_mask;
13796     uint bitmap_size;
13797
13798     for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13799     {
13800       if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13801
13802       bitmap_nums = 1 << bitmap_bits;
13803
13804       bitmap_mask = bitmap_nums - 1;
13805
13806       bitmap_size = bitmap_nums * sizeof (uint);
13807
13808       if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13809
13810       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;
13811       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;
13812
13813       break;
13814     }
13815
13816     bitmap_nums = 1 << bitmap_bits;
13817
13818     bitmap_mask = bitmap_nums - 1;
13819
13820     bitmap_size = bitmap_nums * sizeof (uint);
13821
13822     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);
13823     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);
13824
13825     /**
13826      * prepare quick rule
13827      */
13828
13829     data.rule_buf_l = rule_buf_l;
13830     data.rule_buf_r = rule_buf_r;
13831
13832     int rule_len_l = (int) strlen (rule_buf_l);
13833     int rule_len_r = (int) strlen (rule_buf_r);
13834
13835     data.rule_len_l = rule_len_l;
13836     data.rule_len_r = rule_len_r;
13837
13838     /**
13839      * load rules
13840      */
13841
13842     uint *all_kernel_rules_cnt = NULL;
13843
13844     kernel_rule_t **all_kernel_rules_buf = NULL;
13845
13846     if (rp_files_cnt)
13847     {
13848       all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13849
13850       all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13851     }
13852
13853     char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13854
13855     int rule_len = 0;
13856
13857     for (uint i = 0; i < rp_files_cnt; i++)
13858     {
13859       uint kernel_rules_avail = 0;
13860
13861       uint kernel_rules_cnt = 0;
13862
13863       kernel_rule_t *kernel_rules_buf = NULL;
13864
13865       char *rp_file = rp_files[i];
13866
13867       char in[BLOCK_SIZE]  = { 0 };
13868       char out[BLOCK_SIZE] = { 0 };
13869
13870       FILE *fp = NULL;
13871
13872       uint rule_line = 0;
13873
13874       if ((fp = fopen (rp_file, "rb")) == NULL)
13875       {
13876         log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13877
13878         return -1;
13879       }
13880
13881       while (!feof (fp))
13882       {
13883         memset (rule_buf, 0, HCBUFSIZ);
13884
13885         rule_len = fgetl (fp, rule_buf);
13886
13887         rule_line++;
13888
13889         if (rule_len == 0) continue;
13890
13891         if (rule_buf[0] == '#') continue;
13892
13893         if (kernel_rules_avail == kernel_rules_cnt)
13894         {
13895           kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13896
13897           kernel_rules_avail += INCR_RULES;
13898         }
13899
13900         memset (in,  0, BLOCK_SIZE);
13901         memset (out, 0, BLOCK_SIZE);
13902
13903         int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13904
13905         if (result == -1)
13906         {
13907           log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13908
13909           continue;
13910         }
13911
13912         if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13913         {
13914           log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13915
13916           memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13917
13918           continue;
13919         }
13920
13921         /* its so slow
13922         if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13923         {
13924           log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13925
13926           continue;
13927         }
13928         */
13929
13930         kernel_rules_cnt++;
13931       }
13932
13933       fclose (fp);
13934
13935       all_kernel_rules_cnt[i] = kernel_rules_cnt;
13936
13937       all_kernel_rules_buf[i] = kernel_rules_buf;
13938     }
13939
13940     /**
13941      * merge rules or automatic rule generator
13942      */
13943
13944     uint kernel_rules_cnt = 0;
13945
13946     kernel_rule_t *kernel_rules_buf = NULL;
13947
13948     if (attack_mode == ATTACK_MODE_STRAIGHT)
13949     {
13950       if (rp_files_cnt)
13951       {
13952         kernel_rules_cnt = 1;
13953
13954         uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13955
13956         repeats[0] = kernel_rules_cnt;
13957
13958         for (uint i = 0; i < rp_files_cnt; i++)
13959         {
13960           kernel_rules_cnt *= all_kernel_rules_cnt[i];
13961
13962           repeats[i + 1] = kernel_rules_cnt;
13963         }
13964
13965         kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13966
13967         memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13968
13969         for (uint i = 0; i < kernel_rules_cnt; i++)
13970         {
13971           uint out_pos = 0;
13972
13973           kernel_rule_t *out = &kernel_rules_buf[i];
13974
13975           for (uint j = 0; j < rp_files_cnt; j++)
13976           {
13977             uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13978             uint in_pos;
13979
13980             kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13981
13982             for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13983             {
13984               if (out_pos == RULES_MAX - 1)
13985               {
13986                 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13987
13988                 break;
13989               }
13990
13991               out->cmds[out_pos] = in->cmds[in_pos];
13992             }
13993           }
13994         }
13995
13996         local_free (repeats);
13997       }
13998       else if (rp_gen)
13999       {
14000         uint kernel_rules_avail = 0;
14001
14002         while (kernel_rules_cnt < rp_gen)
14003         {
14004           if (kernel_rules_avail == kernel_rules_cnt)
14005           {
14006             kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
14007
14008             kernel_rules_avail += INCR_RULES;
14009           }
14010
14011           memset (rule_buf, 0, HCBUFSIZ);
14012
14013           rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
14014
14015           if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
14016
14017           kernel_rules_cnt++;
14018         }
14019       }
14020     }
14021
14022     myfree (rule_buf);
14023
14024     /**
14025      * generate NOP rules
14026      */
14027
14028     if ((rp_files_cnt == 0) && (rp_gen == 0))
14029     {
14030       kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
14031
14032       kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
14033
14034       kernel_rules_cnt++;
14035     }
14036
14037     data.kernel_rules_cnt = kernel_rules_cnt;
14038     data.kernel_rules_buf = kernel_rules_buf;
14039
14040     if (kernel_rules_cnt == 0)
14041     {
14042       log_error ("ERROR: No valid rules left");
14043
14044       return -1;
14045     }
14046
14047     /**
14048      * OpenCL platforms: detect
14049      */
14050
14051     cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
14052     cl_device_id platform_devices[DEVICES_MAX] = { 0 };
14053
14054     cl_uint platforms_cnt = 0;
14055     cl_uint platform_devices_cnt = 0;
14056
14057     if (keyspace == 0)
14058     {
14059       cl_int CL_err = hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
14060
14061       if (CL_err != CL_SUCCESS)
14062       {
14063         log_error ("ERROR: clGetPlatformIDs(): %s\n", val2cstr_cl (CL_err));
14064
14065         return -1;
14066       }
14067
14068       if (platforms_cnt == 0)
14069       {
14070         log_info ("");
14071         log_info ("ATTENTION! No OpenCL compatible platform found");
14072         log_info ("");
14073         log_info ("You're probably missing the OpenCL runtime installation");
14074         log_info ("  AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
14075         log_info ("  Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
14076         log_info ("  NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
14077         log_info ("");
14078
14079         return -1;
14080       }
14081
14082       if (opencl_platforms_filter != (uint) -1)
14083       {
14084         uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
14085
14086         if (opencl_platforms_filter > platform_cnt_mask)
14087         {
14088           log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
14089
14090           return -1;
14091         }
14092       }
14093     }
14094
14095     if (opencl_device_types == NULL)
14096     {
14097       /**
14098        * OpenCL device types:
14099        *   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.
14100        */
14101
14102       cl_device_type device_types_all = 0;
14103
14104       for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14105       {
14106         if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
14107
14108         cl_platform_id platform = platforms[platform_id];
14109
14110         cl_int CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14111
14112         if (CL_err != CL_SUCCESS)
14113         {
14114           //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14115
14116           //return -1;
14117
14118           // Silently ignore at this point, it will be reused later and create a note for the user at that point
14119
14120           continue;
14121         }
14122
14123         for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14124         {
14125           cl_device_id device = platform_devices[platform_devices_id];
14126
14127           cl_device_type device_type;
14128
14129           cl_int CL_err = hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14130
14131           if (CL_err != CL_SUCCESS)
14132           {
14133             log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14134
14135             return -1;
14136           }
14137
14138           device_types_all |= device_type;
14139         }
14140       }
14141
14142       // In such a case, automatically enable CPU device type support, since it's disabled by default.
14143
14144       if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
14145       {
14146         device_types_filter |= CL_DEVICE_TYPE_CPU;
14147       }
14148
14149       // In another case, when the user uses --stdout, using CPU devices is much faster to setup
14150       // If we have a CPU device, force it to be used
14151
14152       if (stdout_flag == 1)
14153       {
14154         if (device_types_all & CL_DEVICE_TYPE_CPU)
14155         {
14156           device_types_filter = CL_DEVICE_TYPE_CPU;
14157         }
14158       }
14159     }
14160
14161     /**
14162      * OpenCL devices: simply push all devices from all platforms into the same device array
14163      */
14164
14165     int need_adl     = 0;
14166     int need_nvapi   = 0;
14167     int need_nvml    = 0;
14168     int need_xnvctrl = 0;
14169
14170     hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
14171
14172     data.devices_param = devices_param;
14173
14174     uint devices_cnt = 0;
14175
14176     uint devices_active = 0;
14177
14178     for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14179     {
14180       cl_int CL_err = CL_SUCCESS;
14181
14182       cl_platform_id platform = platforms[platform_id];
14183
14184       char platform_vendor[INFOSZ] = { 0 };
14185
14186       CL_err = hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
14187
14188       if (CL_err != CL_SUCCESS)
14189       {
14190         log_error ("ERROR: clGetPlatformInfo(): %s\n", val2cstr_cl (CL_err));
14191
14192         return -1;
14193       }
14194
14195       // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
14196       // this causes trouble with vendor id based macros
14197       // we'll assign generic to those without special optimization available
14198
14199       cl_uint platform_vendor_id = 0;
14200
14201       if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
14202       {
14203         platform_vendor_id = VENDOR_ID_AMD;
14204       }
14205       else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14206       {
14207         platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14208       }
14209       else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
14210       {
14211         platform_vendor_id = VENDOR_ID_APPLE;
14212       }
14213       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14214       {
14215         platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14216       }
14217       else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
14218       {
14219         platform_vendor_id = VENDOR_ID_INTEL_SDK;
14220       }
14221       else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
14222       {
14223         platform_vendor_id = VENDOR_ID_MESA;
14224       }
14225       else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
14226       {
14227         platform_vendor_id = VENDOR_ID_NV;
14228       }
14229       else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
14230       {
14231         platform_vendor_id = VENDOR_ID_POCL;
14232       }
14233       else
14234       {
14235         platform_vendor_id = VENDOR_ID_GENERIC;
14236       }
14237
14238       uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
14239
14240       CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14241
14242       if (CL_err != CL_SUCCESS)
14243       {
14244         //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14245
14246         //return -1;
14247
14248         platform_skipped = 2;
14249       }
14250
14251       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14252       {
14253         if (machine_readable == 0)
14254         {
14255           if (platform_skipped == 0)
14256           {
14257             const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
14258
14259             char line[256] = { 0 };
14260
14261             for (int i = 0; i < len; i++) line[i] = '=';
14262
14263             log_info (line);
14264           }
14265           else if (platform_skipped == 1)
14266           {
14267             log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
14268             log_info ("");
14269           }
14270           else if (platform_skipped == 2)
14271           {
14272             log_info ("OpenCL Platform #%u: %s, skipped! No OpenCL compatible devices found", platform_id + 1, platform_vendor);
14273             log_info ("");
14274           }
14275         }
14276       }
14277
14278       if (platform_skipped == 1) continue;
14279       if (platform_skipped == 2) continue;
14280
14281       for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14282       {
14283         size_t param_value_size = 0;
14284
14285         const uint device_id = devices_cnt;
14286
14287         hc_device_param_t *device_param = &data.devices_param[device_id];
14288
14289         device_param->platform_vendor_id = platform_vendor_id;
14290
14291         device_param->device = platform_devices[platform_devices_id];
14292
14293         device_param->device_id = device_id;
14294
14295         device_param->platform_devices_id = platform_devices_id;
14296
14297         device_param->platform = platform;
14298
14299         // device_type
14300
14301         cl_device_type device_type;
14302
14303         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14304
14305         if (CL_err != CL_SUCCESS)
14306         {
14307           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14308
14309           return -1;
14310         }
14311
14312         device_type &= ~CL_DEVICE_TYPE_DEFAULT;
14313
14314         device_param->device_type = device_type;
14315
14316         // device_name
14317
14318         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
14319
14320         if (CL_err != CL_SUCCESS)
14321         {
14322           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14323
14324           return -1;
14325         }
14326
14327         char *device_name = (char *) mymalloc (param_value_size);
14328
14329         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
14330
14331         if (CL_err != CL_SUCCESS)
14332         {
14333           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14334
14335           return -1;
14336         }
14337
14338         device_param->device_name = device_name;
14339
14340         // device_vendor
14341
14342         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
14343
14344         if (CL_err != CL_SUCCESS)
14345         {
14346           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14347
14348           return -1;
14349         }
14350
14351         char *device_vendor = (char *) mymalloc (param_value_size);
14352
14353         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
14354
14355         if (CL_err != CL_SUCCESS)
14356         {
14357           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14358
14359           return -1;
14360         }
14361
14362         device_param->device_vendor = device_vendor;
14363
14364         cl_uint device_vendor_id = 0;
14365
14366         if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
14367         {
14368           device_vendor_id = VENDOR_ID_AMD;
14369         }
14370         else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14371         {
14372           device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14373         }
14374         else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
14375         {
14376           device_vendor_id = VENDOR_ID_APPLE;
14377         }
14378         else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14379         {
14380           device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14381         }
14382         else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
14383         {
14384           device_vendor_id = VENDOR_ID_INTEL_SDK;
14385         }
14386         else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
14387         {
14388           device_vendor_id = VENDOR_ID_MESA;
14389         }
14390         else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
14391         {
14392           device_vendor_id = VENDOR_ID_NV;
14393         }
14394         else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
14395         {
14396           device_vendor_id = VENDOR_ID_POCL;
14397         }
14398         else
14399         {
14400           device_vendor_id = VENDOR_ID_GENERIC;
14401         }
14402
14403         device_param->device_vendor_id = device_vendor_id;
14404
14405         // tuning db
14406
14407         tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14408
14409         // device_version
14410
14411         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14412
14413         if (CL_err != CL_SUCCESS)
14414         {
14415           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14416
14417           return -1;
14418         }
14419
14420         char *device_version = (char *) mymalloc (param_value_size);
14421
14422         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14423
14424         if (CL_err != CL_SUCCESS)
14425         {
14426           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14427
14428           return -1;
14429         }
14430
14431         device_param->device_version = device_version;
14432
14433         // device_opencl_version
14434
14435         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14436
14437         if (CL_err != CL_SUCCESS)
14438         {
14439           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14440
14441           return -1;
14442         }
14443
14444         char *device_opencl_version = (char *) mymalloc (param_value_size);
14445
14446         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14447
14448         if (CL_err != CL_SUCCESS)
14449         {
14450           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14451
14452           return -1;
14453         }
14454
14455         device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14456
14457         myfree (device_opencl_version);
14458
14459         // vector_width
14460
14461         cl_uint vector_width;
14462
14463         if (opencl_vector_width_chgd == 0)
14464         {
14465           if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14466           {
14467             if (opti_type & OPTI_TYPE_USES_BITS_64)
14468             {
14469               CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14470
14471               if (CL_err != CL_SUCCESS)
14472               {
14473                 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14474
14475                 return -1;
14476               }
14477             }
14478             else
14479             {
14480               CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,  sizeof (vector_width), &vector_width, NULL);
14481
14482               if (CL_err != CL_SUCCESS)
14483               {
14484                 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14485
14486                 return -1;
14487               }
14488             }
14489           }
14490           else
14491           {
14492             vector_width = (cl_uint) tuningdb_entry->vector_width;
14493           }
14494         }
14495         else
14496         {
14497           vector_width = opencl_vector_width;
14498         }
14499
14500         if (vector_width > 16) vector_width = 16;
14501
14502         device_param->vector_width = vector_width;
14503
14504         // max_compute_units
14505
14506         cl_uint device_processors;
14507
14508         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14509
14510         if (CL_err != CL_SUCCESS)
14511         {
14512           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14513
14514           return -1;
14515         }
14516
14517         device_param->device_processors = device_processors;
14518
14519         // device_maxmem_alloc
14520         // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14521
14522         cl_ulong device_maxmem_alloc;
14523
14524         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14525
14526         if (CL_err != CL_SUCCESS)
14527         {
14528           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14529
14530           return -1;
14531         }
14532
14533         device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14534
14535         // device_global_mem
14536
14537         cl_ulong device_global_mem;
14538
14539         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14540
14541         if (CL_err != CL_SUCCESS)
14542         {
14543           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14544
14545           return -1;
14546         }
14547
14548         device_param->device_global_mem = device_global_mem;
14549
14550         // max_work_group_size
14551
14552         size_t device_maxworkgroup_size;
14553
14554         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14555
14556         if (CL_err != CL_SUCCESS)
14557         {
14558           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14559
14560           return -1;
14561         }
14562
14563         device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14564
14565         // max_clock_frequency
14566
14567         cl_uint device_maxclock_frequency;
14568
14569         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14570
14571         if (CL_err != CL_SUCCESS)
14572         {
14573           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14574
14575           return -1;
14576         }
14577
14578         device_param->device_maxclock_frequency = device_maxclock_frequency;
14579
14580         // device_endian_little
14581
14582         cl_bool device_endian_little;
14583
14584         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14585
14586         if (CL_err != CL_SUCCESS)
14587         {
14588           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14589
14590           return -1;
14591         }
14592
14593         if (device_endian_little == CL_FALSE)
14594         {
14595           log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14596
14597           device_param->skipped = 1;
14598         }
14599
14600         // device_available
14601
14602         cl_bool device_available;
14603
14604         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14605
14606         if (CL_err != CL_SUCCESS)
14607         {
14608           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14609
14610           return -1;
14611         }
14612
14613         if (device_available == CL_FALSE)
14614         {
14615           log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14616
14617           device_param->skipped = 1;
14618         }
14619
14620         // device_compiler_available
14621
14622         cl_bool device_compiler_available;
14623
14624         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14625
14626         if (CL_err != CL_SUCCESS)
14627         {
14628           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14629
14630           return -1;
14631         }
14632
14633         if (device_compiler_available == CL_FALSE)
14634         {
14635           log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14636
14637           device_param->skipped = 1;
14638         }
14639
14640         // device_execution_capabilities
14641
14642         cl_device_exec_capabilities device_execution_capabilities;
14643
14644         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14645
14646         if (CL_err != CL_SUCCESS)
14647         {
14648           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14649
14650           return -1;
14651         }
14652
14653         if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14654         {
14655           log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14656
14657           device_param->skipped = 1;
14658         }
14659
14660         // device_extensions
14661
14662         size_t device_extensions_size;
14663
14664         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14665
14666         if (CL_err != CL_SUCCESS)
14667         {
14668           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14669
14670           return -1;
14671         }
14672
14673         char *device_extensions = mymalloc (device_extensions_size + 1);
14674
14675         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14676
14677         if (CL_err != CL_SUCCESS)
14678         {
14679           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14680
14681           return -1;
14682         }
14683
14684         if (strstr (device_extensions, "base_atomics") == 0)
14685         {
14686           log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14687
14688           device_param->skipped = 1;
14689         }
14690
14691         if (strstr (device_extensions, "byte_addressable_store") == 0)
14692         {
14693           log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14694
14695           device_param->skipped = 1;
14696         }
14697
14698         myfree (device_extensions);
14699
14700         // device_local_mem_size
14701
14702         cl_ulong device_local_mem_size;
14703
14704         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14705
14706         if (CL_err != CL_SUCCESS)
14707         {
14708           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14709
14710           return -1;
14711         }
14712
14713         if (device_local_mem_size < 32768)
14714         {
14715           log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14716
14717           device_param->skipped = 1;
14718         }
14719
14720         // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14721         // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14722         // This results in both utilizing it for 50%
14723         // However, Intel has much better SIMD control over their own hardware
14724         // It makes sense to give them full control over their own hardware
14725
14726         if (device_type & CL_DEVICE_TYPE_CPU)
14727         {
14728           if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14729           {
14730             if (data.force == 0)
14731             {
14732               if (algorithm_pos == 0)
14733               {
14734                 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14735                 log_info ("             You can use --force to override this but do not post error reports if you do so");
14736               }
14737
14738               device_param->skipped = 1;
14739             }
14740           }
14741         }
14742
14743         // skipped
14744
14745         device_param->skipped |= ((devices_filter      & (1 << device_id)) == 0);
14746         device_param->skipped |= ((device_types_filter & (device_type))    == 0);
14747
14748         // driver_version
14749
14750         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14751
14752         if (CL_err != CL_SUCCESS)
14753         {
14754           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14755
14756           return -1;
14757         }
14758
14759         char *driver_version = (char *) mymalloc (param_value_size);
14760
14761         CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14762
14763         if (CL_err != CL_SUCCESS)
14764         {
14765           log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14766
14767           return -1;
14768         }
14769
14770         device_param->driver_version = driver_version;
14771
14772         // device_name_chksum
14773
14774         char *device_name_chksum = (char *) mymalloc (INFOSZ);
14775
14776         #if __x86_64__
14777         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);
14778         #else
14779         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);
14780         #endif
14781
14782         uint device_name_digest[4] = { 0 };
14783
14784         md5_64 ((uint *) device_name_chksum, device_name_digest);
14785
14786         snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14787
14788         device_param->device_name_chksum = device_name_chksum;
14789
14790         // vendor specific
14791
14792         if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14793         {
14794           if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14795           {
14796             need_adl = 1;
14797           }
14798
14799           if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14800           {
14801             need_nvml = 1;
14802
14803             #ifdef __linux__
14804             need_xnvctrl = 1;
14805             #endif
14806
14807             #ifdef WIN
14808             need_nvapi = 1;
14809             #endif
14810           }
14811         }
14812
14813         if (device_type & CL_DEVICE_TYPE_GPU)
14814         {
14815           if (device_vendor_id == VENDOR_ID_NV)
14816           {
14817             cl_uint kernel_exec_timeout = 0;
14818
14819             #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV            0x4005
14820
14821             CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14822
14823             if (CL_err != CL_SUCCESS)
14824             {
14825               log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14826
14827               return -1;
14828             }
14829
14830             device_param->kernel_exec_timeout = kernel_exec_timeout;
14831
14832             cl_uint sm_minor = 0;
14833             cl_uint sm_major = 0;
14834
14835             #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV       0x4000
14836             #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV       0x4001
14837
14838             CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14839
14840             if (CL_err != CL_SUCCESS)
14841             {
14842               log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14843
14844               return -1;
14845             }
14846
14847             CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14848
14849             if (CL_err != CL_SUCCESS)
14850             {
14851               log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14852
14853               return -1;
14854             }
14855
14856             device_param->sm_minor = sm_minor;
14857             device_param->sm_major = sm_major;
14858
14859             // CPU burning loop damper
14860             // Value is given as number between 0-100
14861             // By default 100%
14862
14863             device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14864
14865             if (nvidia_spin_damp_chgd == 0)
14866             {
14867               if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14868               {
14869                 /**
14870                  * the workaround is not a friend of rule based attacks
14871                  * the words from the wordlist combined with fast and slow rules cause
14872                  * fluctuations which cause inaccurate wait time estimations
14873                  * using a reduced damping percentage almost compensates this
14874                  */
14875
14876                 device_param->nvidia_spin_damp = 64;
14877               }
14878             }
14879
14880             device_param->nvidia_spin_damp /= 100;
14881           }
14882         }
14883
14884         // display results
14885
14886         if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14887         {
14888           if (machine_readable == 0)
14889           {
14890             if (device_param->skipped == 0)
14891             {
14892               log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14893                         device_id + 1,
14894                         device_name,
14895                         (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14896                         (unsigned int) (device_global_mem   / 1024 / 1024),
14897                         (unsigned int)  device_processors);
14898             }
14899             else
14900             {
14901               log_info ("- Device #%u: %s, skipped",
14902                         device_id + 1,
14903                         device_name);
14904             }
14905           }
14906         }
14907
14908         // common driver check
14909
14910         if (device_param->skipped == 0)
14911         {
14912           if (device_type & CL_DEVICE_TYPE_GPU)
14913           {
14914             if (platform_vendor_id == VENDOR_ID_AMD)
14915             {
14916               int catalyst_check = (force == 1) ? 0 : 1;
14917
14918               int catalyst_warn = 0;
14919
14920               int catalyst_broken = 0;
14921
14922               if (catalyst_check == 1)
14923               {
14924                 catalyst_warn = 1;
14925
14926                 // v14.9 and higher
14927                 if (atoi (device_param->driver_version) >= 1573)
14928                 {
14929                   catalyst_warn = 0;
14930                 }
14931
14932                 catalyst_check = 0;
14933               }
14934
14935               if (catalyst_broken == 1)
14936               {
14937                 log_info ("");
14938                 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14939                 log_info ("It passes over cracked hashes and will not report them as cracked");
14940                 log_info ("You are STRONGLY encouraged not to use it");
14941                 log_info ("You can use --force to override this but do not post error reports if you do so");
14942                 log_info ("");
14943
14944                 return -1;
14945               }
14946
14947               if (catalyst_warn == 1)
14948               {
14949                 log_info ("");
14950                 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14951                 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14952                 log_info ("See hashcat's homepage for official supported catalyst drivers");
14953                 #ifdef _WIN
14954                 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14955                 #endif
14956                 log_info ("You can use --force to override this but do not post error reports if you do so");
14957                 log_info ("");
14958
14959                 return -1;
14960               }
14961             }
14962             else if (platform_vendor_id == VENDOR_ID_NV)
14963             {
14964               if (device_param->kernel_exec_timeout != 0)
14965               {
14966                 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);
14967                 if (data.quiet == 0) log_info ("             See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14968               }
14969             }
14970           }
14971
14972           /* turns out pocl still creates segfaults (because of llvm)
14973           if (device_type & CL_DEVICE_TYPE_CPU)
14974           {
14975             if (platform_vendor_id == VENDOR_ID_AMD)
14976             {
14977               if (force == 0)
14978               {
14979                 log_info ("");
14980                 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14981                 log_info ("You are STRONGLY encouraged not to use it");
14982                 log_info ("You can use --force to override this but do not post error reports if you do so");
14983                 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14984                 log_info ("");
14985
14986                 return -1;
14987               }
14988             }
14989           }
14990           */
14991
14992           /**
14993            * kernel accel and loops tuning db adjustment
14994            */
14995
14996           device_param->kernel_accel_min = 1;
14997           device_param->kernel_accel_max = 1024;
14998
14999           device_param->kernel_loops_min = 1;
15000           device_param->kernel_loops_max = 1024;
15001
15002           tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
15003
15004           if (tuningdb_entry)
15005           {
15006             u32 _kernel_accel = tuningdb_entry->kernel_accel;
15007             u32 _kernel_loops = tuningdb_entry->kernel_loops;
15008
15009             if (_kernel_accel)
15010             {
15011               device_param->kernel_accel_min = _kernel_accel;
15012               device_param->kernel_accel_max = _kernel_accel;
15013             }
15014
15015             if (_kernel_loops)
15016             {
15017               if (workload_profile == 1)
15018               {
15019                 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
15020               }
15021               else if (workload_profile == 2)
15022               {
15023                 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
15024               }
15025
15026               device_param->kernel_loops_min = _kernel_loops;
15027               device_param->kernel_loops_max = _kernel_loops;
15028             }
15029           }
15030
15031           // commandline parameters overwrite tuningdb entries
15032
15033           if (kernel_accel)
15034           {
15035             device_param->kernel_accel_min = kernel_accel;
15036             device_param->kernel_accel_max = kernel_accel;
15037           }
15038
15039           if (kernel_loops)
15040           {
15041             device_param->kernel_loops_min = kernel_loops;
15042             device_param->kernel_loops_max = kernel_loops;
15043           }
15044
15045           /**
15046            * activate device
15047            */
15048
15049           devices_active++;
15050         }
15051
15052         // next please
15053
15054         devices_cnt++;
15055       }
15056
15057       if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
15058       {
15059         if (machine_readable == 0)
15060         {
15061           log_info ("");
15062         }
15063       }
15064     }
15065
15066     if (keyspace == 0 && devices_active == 0)
15067     {
15068       log_error ("ERROR: No devices found/left");
15069
15070       return -1;
15071     }
15072
15073     // 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)
15074
15075     if (devices_filter != (uint) -1)
15076     {
15077       uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
15078
15079       if (devices_filter > devices_cnt_mask)
15080       {
15081         log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
15082
15083         return -1;
15084       }
15085     }
15086
15087     data.devices_cnt = devices_cnt;
15088
15089     data.devices_active = devices_active;
15090
15091     /**
15092      * HM devices: init
15093      */
15094
15095     #ifdef HAVE_HWMON
15096     hm_attrs_t hm_adapters_adl[DEVICES_MAX];
15097     hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
15098     hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
15099     hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
15100
15101     memset (hm_adapters_adl,     0, sizeof (hm_adapters_adl));
15102     memset (hm_adapters_nvapi,   0, sizeof (hm_adapters_nvapi));
15103     memset (hm_adapters_nvml,    0, sizeof (hm_adapters_nvml));
15104     memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
15105
15106     if (gpu_temp_disable == 0)
15107     {
15108       ADL_PTR     *adl     = (ADL_PTR *)     mymalloc (sizeof (ADL_PTR));
15109       NVAPI_PTR   *nvapi   = (NVAPI_PTR *)   mymalloc (sizeof (NVAPI_PTR));
15110       NVML_PTR    *nvml    = (NVML_PTR *)    mymalloc (sizeof (NVML_PTR));
15111       XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
15112
15113       data.hm_adl     = NULL;
15114       data.hm_nvapi   = NULL;
15115       data.hm_nvml    = NULL;
15116       data.hm_xnvctrl = NULL;
15117
15118       if ((need_nvml == 1) && (nvml_init (nvml) == 0))
15119       {
15120         data.hm_nvml = nvml;
15121       }
15122
15123       if (data.hm_nvml)
15124       {
15125         if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
15126         {
15127           HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
15128
15129           int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
15130
15131           int tmp_out = 0;
15132
15133           for (int i = 0; i < tmp_in; i++)
15134           {
15135             hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
15136           }
15137
15138           for (int i = 0; i < tmp_out; i++)
15139           {
15140             unsigned int speed;
15141
15142             if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
15143
15144             // doesn't seem to create any advantages
15145             //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
15146             //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
15147           }
15148         }
15149       }
15150
15151       if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
15152       {
15153         data.hm_nvapi = nvapi;
15154       }
15155
15156       if (data.hm_nvapi)
15157       {
15158         if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
15159         {
15160           HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
15161
15162           int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
15163
15164           int tmp_out = 0;
15165
15166           for (int i = 0; i < tmp_in; i++)
15167           {
15168             hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
15169           }
15170         }
15171       }
15172
15173       if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
15174       {
15175         data.hm_xnvctrl = xnvctrl;
15176       }
15177
15178       if (data.hm_xnvctrl)
15179       {
15180         if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
15181         {
15182           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15183           {
15184             hc_device_param_t *device_param = &data.devices_param[device_id];
15185
15186             if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15187
15188             hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
15189
15190             int speed = 0;
15191
15192             if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
15193           }
15194         }
15195       }
15196
15197       if ((need_adl == 1) && (adl_init (adl) == 0))
15198       {
15199         data.hm_adl = adl;
15200       }
15201
15202       if (data.hm_adl)
15203       {
15204         if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
15205         {
15206           // total number of adapters
15207
15208           int hm_adapters_num;
15209
15210           if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1;
15211
15212           // adapter info
15213
15214           LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
15215
15216           if (lpAdapterInfo == NULL) return -1;
15217
15218           // get a list (of ids of) valid/usable adapters
15219
15220           int num_adl_adapters = 0;
15221
15222           u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
15223
15224           if (num_adl_adapters > 0)
15225           {
15226             hc_thread_mutex_lock (mux_adl);
15227
15228             // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
15229
15230             hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15231
15232             hm_get_overdrive_version  (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15233             hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15234
15235             hc_thread_mutex_unlock (mux_adl);
15236           }
15237
15238           myfree (valid_adl_device_list);
15239           myfree (lpAdapterInfo);
15240         }
15241       }
15242
15243       if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15244       {
15245         gpu_temp_disable = 1;
15246       }
15247     }
15248
15249     /**
15250      * OpenCL devices: allocate buffer for device specific information
15251      */
15252
15253     ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
15254
15255     int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
15256
15257     unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
15258
15259     /**
15260      * User-defined GPU temp handling
15261      */
15262
15263     if (gpu_temp_disable == 1)
15264     {
15265       gpu_temp_abort  = 0;
15266       gpu_temp_retain = 0;
15267     }
15268
15269     if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
15270     {
15271       if (gpu_temp_abort < gpu_temp_retain)
15272       {
15273         log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
15274
15275         return -1;
15276       }
15277     }
15278
15279     data.gpu_temp_disable = gpu_temp_disable;
15280     data.gpu_temp_abort   = gpu_temp_abort;
15281     data.gpu_temp_retain  = gpu_temp_retain;
15282     #endif
15283
15284     /**
15285      * enable custom signal handler(s)
15286      */
15287
15288     if (benchmark == 0)
15289     {
15290       hc_signal (sigHandler_default);
15291     }
15292     else
15293     {
15294       hc_signal (sigHandler_benchmark);
15295     }
15296
15297     /**
15298      * inform the user
15299      */
15300
15301     if (data.quiet == 0)
15302     {
15303       log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
15304
15305       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);
15306
15307       if (attack_mode == ATTACK_MODE_STRAIGHT)
15308       {
15309         log_info ("Rules: %u", kernel_rules_cnt);
15310       }
15311
15312       if (opti_type)
15313       {
15314         log_info ("Applicable Optimizers:");
15315
15316         for (uint i = 0; i < 32; i++)
15317         {
15318           const uint opti_bit = 1u << i;
15319
15320           if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
15321         }
15322       }
15323
15324       /**
15325        * Watchdog and Temperature balance
15326        */
15327
15328       #ifdef HAVE_HWMON
15329       if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15330       {
15331         log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
15332       }
15333
15334       if (gpu_temp_abort == 0)
15335       {
15336         log_info ("Watchdog: Temperature abort trigger disabled");
15337       }
15338       else
15339       {
15340         log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
15341       }
15342
15343       if (gpu_temp_retain == 0)
15344       {
15345         log_info ("Watchdog: Temperature retain trigger disabled");
15346       }
15347       else
15348       {
15349         log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
15350       }
15351
15352       if (data.quiet == 0) log_info ("");
15353       #endif
15354     }
15355
15356     #ifdef HAVE_HWMON
15357
15358     /**
15359      * HM devices: copy
15360      */
15361
15362     if (gpu_temp_disable == 0)
15363     {
15364       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15365       {
15366         hc_device_param_t *device_param = &data.devices_param[device_id];
15367
15368         if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15369
15370         if (device_param->skipped) continue;
15371
15372         const uint platform_devices_id = device_param->platform_devices_id;
15373
15374         if (device_param->device_vendor_id == VENDOR_ID_AMD)
15375         {
15376           data.hm_device[device_id].adl               = hm_adapters_adl[platform_devices_id].adl;
15377           data.hm_device[device_id].nvapi             = 0;
15378           data.hm_device[device_id].nvml              = 0;
15379           data.hm_device[device_id].xnvctrl           = 0;
15380           data.hm_device[device_id].od_version        = hm_adapters_adl[platform_devices_id].od_version;
15381           data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
15382           data.hm_device[device_id].fan_set_supported = 0;
15383         }
15384
15385         if (device_param->device_vendor_id == VENDOR_ID_NV)
15386         {
15387           data.hm_device[device_id].adl               = 0;
15388           data.hm_device[device_id].nvapi             = hm_adapters_nvapi[platform_devices_id].nvapi;
15389           data.hm_device[device_id].nvml              = hm_adapters_nvml[platform_devices_id].nvml;
15390           data.hm_device[device_id].xnvctrl           = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
15391           data.hm_device[device_id].od_version        = 0;
15392           data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
15393           data.hm_device[device_id].fan_set_supported = 0;
15394         }
15395       }
15396     }
15397
15398     /**
15399      * powertune on user request
15400      */
15401
15402     if (powertune_enable == 1)
15403     {
15404       hc_thread_mutex_lock (mux_adl);
15405
15406       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15407       {
15408         hc_device_param_t *device_param = &data.devices_param[device_id];
15409
15410         if (device_param->skipped) continue;
15411
15412         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
15413         {
15414           /**
15415            * Temporary fix:
15416            * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
15417            * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
15418            * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
15419            * Driver / ADL bug?
15420            */
15421
15422           if (data.hm_device[device_id].od_version == 6)
15423           {
15424             int ADL_rc;
15425
15426             // check powertune capabilities first, if not available then skip device
15427
15428             int powertune_supported = 0;
15429
15430             if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
15431             {
15432               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15433
15434               return -1;
15435             }
15436
15437             // first backup current value, we will restore it later
15438
15439             if (powertune_supported != 0)
15440             {
15441               // powercontrol settings
15442
15443               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15444
15445               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
15446               {
15447                 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
15448               }
15449
15450               if (ADL_rc != ADL_OK)
15451               {
15452                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15453
15454                 return -1;
15455               }
15456
15457               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15458               {
15459                 log_error ("ERROR: Failed to set new ADL PowerControl values");
15460
15461                 return -1;
15462               }
15463
15464               // clocks
15465
15466               memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15467
15468               od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15469
15470               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)
15471               {
15472                 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15473
15474                 return -1;
15475               }
15476
15477               // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15478
15479               ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15480
15481               if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
15482               {
15483                 log_error ("ERROR: Failed to get ADL device capabilities");
15484
15485                 return -1;
15486               }
15487
15488               int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15489               int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15490
15491               int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15492               int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15493
15494               int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15495               int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15496
15497               // warning if profile has too low max values
15498
15499               if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15500               {
15501                 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15502               }
15503
15504               if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15505               {
15506                 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15507               }
15508
15509               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15510
15511               performance_state->iNumberOfPerformanceLevels = 2;
15512
15513               performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15514               performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15515               performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15516               performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15517
15518               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)
15519               {
15520                 log_info ("ERROR: Failed to set ADL performance state");
15521
15522                 return -1;
15523               }
15524
15525               local_free (performance_state);
15526             }
15527
15528             // set powertune value only
15529
15530             if (powertune_supported != 0)
15531             {
15532               // powertune set
15533               ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15534
15535               if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
15536               {
15537                 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15538
15539                 return -1;
15540               }
15541
15542               if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15543               {
15544                 log_error ("ERROR: Failed to set new ADL PowerControl values");
15545
15546                 return -1;
15547               }
15548             }
15549           }
15550         }
15551
15552         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
15553         {
15554           // first backup current value, we will restore it later
15555
15556           unsigned int limit;
15557
15558           int powertune_supported = 0;
15559
15560           if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
15561           {
15562             powertune_supported = 1;
15563           }
15564
15565           // if backup worked, activate the maximum allowed
15566
15567           if (powertune_supported != 0)
15568           {
15569             unsigned int minLimit;
15570             unsigned int maxLimit;
15571
15572             if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15573             {
15574               if (maxLimit > 0)
15575               {
15576                 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15577                 {
15578                   // now we can be sure we need to reset later
15579
15580                   nvml_power_limit[device_id] = limit;
15581                 }
15582               }
15583             }
15584           }
15585         }
15586       }
15587
15588       hc_thread_mutex_unlock (mux_adl);
15589     }
15590
15591     #endif // HAVE_HWMON
15592
15593     #ifdef DEBUG
15594     if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15595     #endif
15596
15597     if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15598
15599     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15600     {
15601       cl_int CL_err = CL_SUCCESS;
15602
15603       /**
15604        * host buffer
15605        */
15606
15607       hc_device_param_t *device_param = &data.devices_param[device_id];
15608
15609       if (device_param->skipped) continue;
15610
15611       /**
15612        * device properties
15613        */
15614
15615       const char *device_name_chksum      = device_param->device_name_chksum;
15616       const u32   device_processors       = device_param->device_processors;
15617
15618       /**
15619        * create context for each device
15620        */
15621
15622       cl_context_properties properties[3];
15623
15624       properties[0] = CL_CONTEXT_PLATFORM;
15625       properties[1] = (cl_context_properties) device_param->platform;
15626       properties[2] = 0;
15627
15628       CL_err = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL, &device_param->context);
15629
15630       if (CL_err != CL_SUCCESS)
15631       {
15632         log_error ("ERROR: clCreateContext(): %s\n", val2cstr_cl (CL_err));
15633
15634         return -1;
15635       }
15636
15637       /**
15638        * create command-queue
15639        */
15640
15641       // not supported with NV
15642       // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15643
15644       CL_err = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE, &device_param->command_queue);
15645
15646       if (CL_err != CL_SUCCESS)
15647       {
15648         log_error ("ERROR: clCreateCommandQueue(): %s\n", val2cstr_cl (CL_err));
15649
15650         return -1;
15651       }
15652
15653       /**
15654        * kernel threads: some algorithms need a fixed kernel-threads count
15655        *                 because of shared memory usage or bitslice
15656        *                 there needs to be some upper limit, otherwise there's too much overhead
15657        */
15658
15659       uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15660
15661       if (hash_mode ==  8900) kernel_threads = 64; // Scrypt
15662       if (hash_mode ==  9300) kernel_threads = 64; // Scrypt
15663
15664       if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15665       {
15666         kernel_threads = KERNEL_THREADS_MAX_CPU;
15667       }
15668
15669       if (hash_mode ==  1500) kernel_threads = 64; // DES
15670       if (hash_mode ==  3000) kernel_threads = 64; // DES
15671       if (hash_mode ==  3200) kernel_threads = 8;  // Blowfish
15672       if (hash_mode ==  7500) kernel_threads = 64; // RC4
15673       if (hash_mode ==  9000) kernel_threads = 8;  // Blowfish
15674       if (hash_mode ==  9700) kernel_threads = 64; // RC4
15675       if (hash_mode ==  9710) kernel_threads = 64; // RC4
15676       if (hash_mode ==  9800) kernel_threads = 64; // RC4
15677       if (hash_mode ==  9810) kernel_threads = 64; // RC4
15678       if (hash_mode == 10400) kernel_threads = 64; // RC4
15679       if (hash_mode == 10410) kernel_threads = 64; // RC4
15680       if (hash_mode == 10500) kernel_threads = 64; // RC4
15681       if (hash_mode == 13100) kernel_threads = 64; // RC4
15682
15683       device_param->kernel_threads = kernel_threads;
15684
15685       device_param->hardware_power = device_processors * kernel_threads;
15686
15687       /**
15688        * create input buffers on device : calculate size of fixed memory buffers
15689        */
15690
15691       size_t size_root_css   = SP_PW_MAX *           sizeof (cs_t);
15692       size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15693
15694       device_param->size_root_css   = size_root_css;
15695       device_param->size_markov_css = size_markov_css;
15696
15697       size_t size_results = sizeof (uint);
15698
15699       device_param->size_results = size_results;
15700
15701       size_t size_rules   = kernel_rules_cnt * sizeof (kernel_rule_t);
15702       size_t size_rules_c = KERNEL_RULES     * sizeof (kernel_rule_t);
15703
15704       size_t size_plains  = digests_cnt * sizeof (plain_t);
15705       size_t size_salts   = salts_cnt   * sizeof (salt_t);
15706       size_t size_esalts  = salts_cnt   * esalt_size;
15707
15708       device_param->size_plains   = size_plains;
15709       device_param->size_digests  = size_digests;
15710       device_param->size_shown    = size_shown;
15711       device_param->size_salts    = size_salts;
15712
15713       size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15714       size_t size_bfs   = KERNEL_BFS   * sizeof (bf_t);
15715       size_t size_tm    = 32           * sizeof (bs_word_t);
15716
15717       // scryptV stuff
15718
15719       size_t size_scrypt = 4;
15720
15721       if ((hash_mode == 8900) || (hash_mode == 9300))
15722       {
15723         // we need to check that all hashes have the same scrypt settings
15724
15725         const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15726         const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15727         const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15728
15729         for (uint i = 1; i < salts_cnt; i++)
15730         {
15731           if ((data.salts_buf[i].scrypt_N != scrypt_N)
15732            || (data.salts_buf[i].scrypt_r != scrypt_r)
15733            || (data.salts_buf[i].scrypt_p != scrypt_p))
15734           {
15735             log_error ("ERROR: Mixed scrypt settings not supported");
15736
15737             return -1;
15738           }
15739         }
15740
15741         uint tmto_start = 0;
15742         uint tmto_stop  = 10;
15743
15744         if (scrypt_tmto)
15745         {
15746           tmto_start = scrypt_tmto;
15747         }
15748         else
15749         {
15750           // in case the user did not specify the tmto manually
15751           // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15752
15753           if (hash_mode == 8900)
15754           {
15755             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15756             {
15757               tmto_start = 3;
15758             }
15759             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15760             {
15761               tmto_start = 2;
15762             }
15763           }
15764           else if (hash_mode == 9300)
15765           {
15766             if (device_param->device_vendor_id == VENDOR_ID_AMD)
15767             {
15768               tmto_start = 2;
15769             }
15770             else if (device_param->device_vendor_id == VENDOR_ID_NV)
15771             {
15772               tmto_start = 4;
15773             }
15774           }
15775         }
15776
15777         data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15778
15779         device_param->kernel_accel_min = 1;
15780         device_param->kernel_accel_max = 8;
15781
15782         uint tmto;
15783
15784         for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15785         {
15786           size_scrypt = (128 * scrypt_r) * scrypt_N;
15787
15788           size_scrypt /= 1 << tmto;
15789
15790           size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15791
15792           if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15793           {
15794             if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15795
15796             continue;
15797           }
15798
15799           if (size_scrypt > device_param->device_global_mem)
15800           {
15801             if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15802
15803             continue;
15804           }
15805
15806           for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15807           {
15808             data.scrypt_tmto_final = tmto;
15809           }
15810
15811           break;
15812         }
15813
15814         if (tmto == tmto_stop)
15815         {
15816           log_error ("ERROR: Can't allocate enough device memory");
15817
15818           return -1;
15819         }
15820
15821         if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15822       }
15823
15824       size_t size_scrypt4 = size_scrypt / 4;
15825
15826       /**
15827        * some algorithms need a fixed kernel-loops count
15828        */
15829
15830       if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15831       {
15832         const u32 kernel_loops_fixed = 1024;
15833
15834         device_param->kernel_loops_min = kernel_loops_fixed;
15835         device_param->kernel_loops_max = kernel_loops_fixed;
15836       }
15837
15838       if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15839       {
15840         const u32 kernel_loops_fixed = 1024;
15841
15842         device_param->kernel_loops_min = kernel_loops_fixed;
15843         device_param->kernel_loops_max = kernel_loops_fixed;
15844       }
15845
15846       if (hash_mode == 8900)
15847       {
15848         const u32 kernel_loops_fixed = 1;
15849
15850         device_param->kernel_loops_min = kernel_loops_fixed;
15851         device_param->kernel_loops_max = kernel_loops_fixed;
15852       }
15853
15854       if (hash_mode == 9300)
15855       {
15856         const u32 kernel_loops_fixed = 1;
15857
15858         device_param->kernel_loops_min = kernel_loops_fixed;
15859         device_param->kernel_loops_max = kernel_loops_fixed;
15860       }
15861
15862       if (hash_mode == 12500)
15863       {
15864         const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15865
15866         device_param->kernel_loops_min = kernel_loops_fixed;
15867         device_param->kernel_loops_max = kernel_loops_fixed;
15868       }
15869
15870       /**
15871        * some algorithms have a maximum kernel-loops count
15872        */
15873
15874       if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15875       {
15876         u32 innerloop_cnt = 0;
15877
15878         if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15879         {
15880           if      (data.attack_kern == ATTACK_KERN_STRAIGHT)  innerloop_cnt = data.kernel_rules_cnt;
15881           else if (data.attack_kern == ATTACK_KERN_COMBI)     innerloop_cnt = data.combs_cnt;
15882           else if (data.attack_kern == ATTACK_KERN_BF)        innerloop_cnt = data.bfs_cnt;
15883         }
15884         else
15885         {
15886           innerloop_cnt = data.salts_buf[0].salt_iter;
15887         }
15888
15889         if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15890             (innerloop_cnt <= device_param->kernel_loops_max))
15891         {
15892           device_param->kernel_loops_max = innerloop_cnt;
15893         }
15894       }
15895
15896       u32 kernel_accel_min = device_param->kernel_accel_min;
15897       u32 kernel_accel_max = device_param->kernel_accel_max;
15898
15899       // find out if we would request too much memory on memory blocks which are based on kernel_accel
15900
15901       size_t size_pws   = 4;
15902       size_t size_tmps  = 4;
15903       size_t size_hooks = 4;
15904
15905       while (kernel_accel_max >= kernel_accel_min)
15906       {
15907         const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15908
15909         // size_pws
15910
15911         size_pws = kernel_power_max * sizeof (pw_t);
15912
15913         // size_tmps
15914
15915         switch (hash_mode)
15916         {
15917           case   400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t);          break;
15918           case   500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15919           case   501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15920           case  1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15921           case  1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t);     break;
15922           case  2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t);            break;
15923           case  2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t);             break;
15924           case  3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t);          break;
15925           case  5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t);         break;
15926           case  5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t);      break;
15927           case  6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15928           case  6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15929           case  6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15930           case  6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15931           case  6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15932           case  6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15933           case  6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15934           case  6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15935           case  6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15936           case  6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15937           case  6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15938           case  6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15939           case  6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t);        break;
15940           case  6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t);       break;
15941           case  6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t);       break;
15942           case  6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t);        break;
15943           case  6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t);         break;
15944           case  6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t);        break;
15945           case  7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15946           case  7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15947           case  7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t);     break;
15948           case  7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t);         break;
15949           case  8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15950           case  8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t);      break;
15951           case  8900: size_tmps = kernel_power_max * data.scrypt_tmp_size;           break;
15952           case  9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t);         break;
15953           case  9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t);          break;
15954           case  9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15955           case  9300: size_tmps = kernel_power_max * data.scrypt_tmp_size;           break;
15956           case  9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t);      break;
15957           case  9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t);      break;
15958           case  9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t);      break;
15959           case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15960           case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t);            break;
15961           case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t);       break;
15962           case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t);           break;
15963           case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t);         break;
15964           case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15965           case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t);  break;
15966           case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t);       break;
15967           case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t);      break;
15968           case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15969           case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t);   break;
15970           case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t);        break;
15971           case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t);         break;
15972           case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t);       break;
15973           case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t);            break;
15974           case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t);        break;
15975           case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15976           case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15977           case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t);   break;
15978           case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t);         break;
15979           case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t);         break;
15980           case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t);     break;
15981           case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15982           case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15983           case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15984           case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15985           case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15986           case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t);            break;
15987           case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15988           case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15989           case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15990           case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15991           case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15992           case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15993           case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15994           case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15995           case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15996           case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15997           case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15998           case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t);              break;
15999         };
16000
16001         // size_hooks
16002
16003         if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
16004         {
16005           switch (hash_mode)
16006           {
16007           }
16008         }
16009
16010         // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
16011         // if not, decrease amplifier and try again
16012
16013         int memory_limit_hit = 0;
16014
16015         if (size_pws   > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16016         if (size_tmps  > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16017         if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16018
16019         const u64 size_total
16020           = bitmap_size
16021           + bitmap_size
16022           + bitmap_size
16023           + bitmap_size
16024           + bitmap_size
16025           + bitmap_size
16026           + bitmap_size
16027           + bitmap_size
16028           + size_bfs
16029           + size_combs
16030           + size_digests
16031           + size_esalts
16032           + size_hooks
16033           + size_markov_css
16034           + size_plains
16035           + size_pws
16036           + size_pws // not a bug
16037           + size_results
16038           + size_root_css
16039           + size_rules
16040           + size_rules_c
16041           + size_salts
16042           + size_scrypt4
16043           + size_scrypt4
16044           + size_scrypt4
16045           + size_scrypt4
16046           + size_shown
16047           + size_tm
16048           + size_tmps;
16049
16050         if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
16051
16052         if (memory_limit_hit == 1)
16053         {
16054           kernel_accel_max--;
16055
16056           continue;
16057         }
16058
16059         break;
16060       }
16061
16062       if (kernel_accel_max < kernel_accel_min)
16063       {
16064         log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
16065
16066         return -1;
16067       }
16068
16069       device_param->kernel_accel_min = kernel_accel_min;
16070       device_param->kernel_accel_max = kernel_accel_max;
16071
16072       /*
16073       if (kernel_accel_max < kernel_accel)
16074       {
16075         if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
16076
16077         device_param->kernel_accel = kernel_accel_max;
16078       }
16079       */
16080
16081       device_param->size_bfs     = size_bfs;
16082       device_param->size_combs   = size_combs;
16083       device_param->size_rules   = size_rules;
16084       device_param->size_rules_c = size_rules_c;
16085       device_param->size_pws     = size_pws;
16086       device_param->size_tmps    = size_tmps;
16087       device_param->size_hooks   = size_hooks;
16088
16089       /**
16090        * default building options
16091        */
16092
16093       char cpath[1024] = { 0 };
16094
16095       char build_opts[1024] = { 0 };
16096
16097       #if _WIN
16098
16099       snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
16100
16101       char *cpath_real = mymalloc (MAX_PATH);
16102
16103       if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
16104       {
16105         log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
16106
16107         return -1;
16108       }
16109
16110       naive_replace (cpath_real, '\\', '/');
16111
16112       // not escaping here, windows has quotes
16113
16114       snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
16115
16116       #else
16117
16118       snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
16119
16120       char *cpath_real = mymalloc (PATH_MAX);
16121
16122       if (realpath (cpath, cpath_real) == NULL)
16123       {
16124         log_error ("ERROR: %s: %s", cpath, strerror (errno));
16125
16126         return -1;
16127       }
16128
16129       naive_escape (cpath_real, PATH_MAX,  ' ', '\\');
16130
16131       snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
16132
16133       #endif
16134
16135       // include check
16136       // this test needs to be done manually because of osx opencl runtime
16137       // if there's a problem with permission, its not reporting back and erroring out silently
16138
16139       #define files_cnt 15
16140
16141       const char *files_names[files_cnt] =
16142       {
16143         "inc_cipher_aes256.cl",
16144         "inc_cipher_serpent256.cl",
16145         "inc_cipher_twofish256.cl",
16146         "inc_common.cl",
16147         "inc_comp_multi_bs.cl",
16148         "inc_comp_multi.cl",
16149         "inc_comp_single_bs.cl",
16150         "inc_comp_single.cl",
16151         "inc_hash_constants.h",
16152         "inc_hash_functions.cl",
16153         "inc_rp.cl",
16154         "inc_rp.h",
16155         "inc_simd.cl",
16156         "inc_types.cl",
16157         "inc_vendor.cl",
16158       };
16159
16160       if (chdir (cpath_real) == -1)
16161       {
16162         log_error ("ERROR: %s: %s", cpath_real, strerror (errno));
16163
16164         return -1;
16165       }
16166
16167       for (int i = 0; i < files_cnt; i++)
16168       {
16169         FILE *fd = fopen (files_names[i], "r");
16170
16171         if (fd == NULL)
16172         {
16173           log_error ("ERROR: %s: fopen(): %s", files_names[i], strerror (errno));
16174
16175           return -1;
16176         }
16177
16178         char buf[1];
16179
16180         size_t n = fread (buf, 1, 1, fd);
16181
16182         if (n != 1)
16183         {
16184           log_error ("ERROR: %s: fread(): %s", files_names[i], strerror (errno));
16185
16186           return -1;
16187         }
16188
16189         fclose (fd);
16190       }
16191
16192       myfree (cpath_real);
16193
16194       // we don't have sm_* on vendors not NV but it doesn't matter
16195
16196       char build_opts_new[1024] = { 0 };
16197
16198       snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
16199
16200       strncpy (build_opts, build_opts_new, sizeof (build_opts));
16201
16202       #ifdef DEBUG
16203       log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
16204       #endif
16205
16206       /**
16207        * main kernel
16208        */
16209
16210       {
16211         /**
16212          * kernel source filename
16213          */
16214
16215         char source_file[256] = { 0 };
16216
16217         generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
16218
16219         struct stat sst;
16220
16221         if (stat (source_file, &sst) == -1)
16222         {
16223           log_error ("ERROR: %s: %s", source_file, strerror (errno));
16224
16225           return -1;
16226         }
16227
16228         /**
16229          * kernel cached filename
16230          */
16231
16232         char cached_file[256] = { 0 };
16233
16234         generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
16235
16236         int cached = 1;
16237
16238         struct stat cst;
16239
16240         if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
16241         {
16242           cached = 0;
16243         }
16244
16245         /**
16246          * kernel compile or load
16247          */
16248
16249         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16250
16251         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16252
16253         if (force_jit_compilation == -1)
16254         {
16255           if (cached == 0)
16256           {
16257             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));
16258
16259             load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16260
16261             CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16262
16263             if (CL_err != CL_SUCCESS)
16264             {
16265               log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16266
16267               return -1;
16268             }
16269
16270             CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16271
16272             if (CL_err != CL_SUCCESS)
16273             {
16274               log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16275
16276               //return -1;
16277             }
16278
16279             #ifdef DEBUG
16280             size_t build_log_size = 0;
16281
16282             CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16283
16284             if (CL_err != CL_SUCCESS)
16285             {
16286               log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16287
16288               return -1;
16289             }
16290
16291             if (build_log_size > 1)
16292             {
16293               char *build_log = (char *) mymalloc (build_log_size + 1);
16294
16295               CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16296
16297               if (CL_err != CL_SUCCESS)
16298               {
16299                 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16300
16301                 return -1;
16302               }
16303
16304               puts (build_log);
16305
16306               myfree (build_log);
16307             }
16308             #endif
16309
16310             if (CL_err != CL_SUCCESS)
16311             {
16312               device_param->skipped = true;
16313
16314               log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16315
16316               continue;
16317             }
16318
16319             size_t binary_size;
16320
16321             CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16322
16323             if (CL_err != CL_SUCCESS)
16324             {
16325               log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16326
16327               return -1;
16328             }
16329
16330             u8 *binary = (u8 *) mymalloc (binary_size);
16331
16332             CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16333
16334             if (CL_err != CL_SUCCESS)
16335             {
16336               log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16337
16338               return -1;
16339             }
16340
16341             writeProgramBin (cached_file, binary, binary_size);
16342
16343             local_free (binary);
16344           }
16345           else
16346           {
16347             #ifdef DEBUG
16348             log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16349             #endif
16350
16351             load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16352
16353             CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program);
16354
16355             if (CL_err != CL_SUCCESS)
16356             {
16357               log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16358
16359               return -1;
16360             }
16361
16362             CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16363
16364             if (CL_err != CL_SUCCESS)
16365             {
16366               log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16367
16368               return -1;
16369             }
16370           }
16371         }
16372         else
16373         {
16374           #ifdef DEBUG
16375           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
16376           #endif
16377
16378           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16379
16380           CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16381
16382           if (CL_err != CL_SUCCESS)
16383           {
16384             log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16385
16386             return -1;
16387           }
16388
16389           char build_opts_update[1024] = { 0 };
16390
16391           if (force_jit_compilation == 1500)
16392           {
16393             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
16394           }
16395           else if (force_jit_compilation == 8900)
16396           {
16397             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
16398           }
16399           else
16400           {
16401             snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
16402           }
16403
16404           CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
16405
16406           if (CL_err != CL_SUCCESS)
16407           {
16408             log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16409
16410             //return -1;
16411           }
16412
16413           #ifdef DEBUG
16414           size_t build_log_size = 0;
16415
16416           CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16417
16418           if (CL_err != CL_SUCCESS)
16419           {
16420             log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16421
16422             return -1;
16423           }
16424
16425           if (build_log_size > 1)
16426           {
16427             char *build_log = (char *) mymalloc (build_log_size + 1);
16428
16429             CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16430
16431             if (CL_err != CL_SUCCESS)
16432             {
16433               log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16434
16435               return -1;
16436             }
16437
16438             puts (build_log);
16439
16440             myfree (build_log);
16441           }
16442           #endif
16443
16444           if (CL_err != CL_SUCCESS)
16445           {
16446             device_param->skipped = true;
16447
16448             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16449           }
16450         }
16451
16452         local_free (kernel_lengths);
16453         local_free (kernel_sources[0]);
16454         local_free (kernel_sources);
16455       }
16456
16457       /**
16458        * word generator kernel
16459        */
16460
16461       if (attack_mode != ATTACK_MODE_STRAIGHT)
16462       {
16463         /**
16464          * kernel mp source filename
16465          */
16466
16467         char source_file[256] = { 0 };
16468
16469         generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
16470
16471         struct stat sst;
16472
16473         if (stat (source_file, &sst) == -1)
16474         {
16475           log_error ("ERROR: %s: %s", source_file, strerror (errno));
16476
16477           return -1;
16478         }
16479
16480         /**
16481          * kernel mp cached filename
16482          */
16483
16484         char cached_file[256] = { 0 };
16485
16486         generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
16487
16488         int cached = 1;
16489
16490         struct stat cst;
16491
16492         if (stat (cached_file, &cst) == -1)
16493         {
16494           cached = 0;
16495         }
16496
16497         /**
16498          * kernel compile or load
16499          */
16500
16501         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16502
16503         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16504
16505         if (cached == 0)
16506         {
16507           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));
16508           if (quiet == 0) log_info ("");
16509
16510           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16511
16512           CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_mp);
16513
16514           if (CL_err != CL_SUCCESS)
16515           {
16516             log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16517
16518             return -1;
16519           }
16520
16521           CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16522
16523           if (CL_err != CL_SUCCESS)
16524           {
16525             log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16526
16527             //return -1;
16528           }
16529
16530           if (CL_err != CL_SUCCESS)
16531           {
16532             device_param->skipped = true;
16533
16534             log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16535
16536             continue;
16537           }
16538
16539           size_t binary_size;
16540
16541           CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16542
16543           if (CL_err != CL_SUCCESS)
16544           {
16545             log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16546
16547             return -1;
16548           }
16549
16550           u8 *binary = (u8 *) mymalloc (binary_size);
16551
16552           CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16553
16554           if (CL_err != CL_SUCCESS)
16555           {
16556             log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16557
16558             return -1;
16559           }
16560
16561           writeProgramBin (cached_file, binary, binary_size);
16562
16563           local_free (binary);
16564         }
16565         else
16566         {
16567           #ifdef DEBUG
16568           log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16569           #endif
16570
16571           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16572
16573           CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_mp);
16574
16575           if (CL_err != CL_SUCCESS)
16576           {
16577             log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16578
16579             return -1;
16580           }
16581
16582           CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16583
16584           if (CL_err != CL_SUCCESS)
16585           {
16586             log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16587
16588             return -1;
16589           }
16590         }
16591
16592         local_free (kernel_lengths);
16593         local_free (kernel_sources[0]);
16594         local_free (kernel_sources);
16595       }
16596
16597       /**
16598        * amplifier kernel
16599        */
16600
16601       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16602       {
16603
16604       }
16605       else
16606       {
16607         /**
16608          * kernel amp source filename
16609          */
16610
16611         char source_file[256] = { 0 };
16612
16613         generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
16614
16615         struct stat sst;
16616
16617         if (stat (source_file, &sst) == -1)
16618         {
16619           log_error ("ERROR: %s: %s", source_file, strerror (errno));
16620
16621           return -1;
16622         }
16623
16624         /**
16625          * kernel amp cached filename
16626          */
16627
16628         char cached_file[256] = { 0 };
16629
16630         generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
16631
16632         int cached = 1;
16633
16634         struct stat cst;
16635
16636         if (stat (cached_file, &cst) == -1)
16637         {
16638           cached = 0;
16639         }
16640
16641         /**
16642          * kernel compile or load
16643          */
16644
16645         size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16646
16647         const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16648
16649         if (cached == 0)
16650         {
16651           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));
16652           if (quiet == 0) log_info ("");
16653
16654           load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16655
16656           CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_amp);
16657
16658           if (CL_err != CL_SUCCESS)
16659           {
16660             log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16661
16662             return -1;
16663           }
16664
16665           CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16666
16667           if (CL_err != CL_SUCCESS)
16668           {
16669             log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16670
16671             //return -1;
16672           }
16673
16674           if (CL_err != CL_SUCCESS)
16675           {
16676             device_param->skipped = true;
16677
16678             log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
16679
16680             continue;
16681           }
16682
16683           size_t binary_size;
16684
16685           CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16686
16687           if (CL_err != CL_SUCCESS)
16688           {
16689             log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16690
16691             return -1;
16692           }
16693
16694           u8 *binary = (u8 *) mymalloc (binary_size);
16695
16696           CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16697
16698           if (CL_err != CL_SUCCESS)
16699           {
16700             log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16701
16702             return -1;
16703           }
16704
16705           writeProgramBin (cached_file, binary, binary_size);
16706
16707           local_free (binary);
16708         }
16709         else
16710         {
16711           #ifdef DEBUG
16712           if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16713           #endif
16714
16715           load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16716
16717           CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_amp);
16718
16719           if (CL_err != CL_SUCCESS)
16720           {
16721             log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16722
16723             return -1;
16724           }
16725
16726           CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16727
16728           if (CL_err != CL_SUCCESS)
16729           {
16730             log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16731
16732             return -1;
16733           }
16734         }
16735
16736         local_free (kernel_lengths);
16737         local_free (kernel_sources[0]);
16738         local_free (kernel_sources);
16739       }
16740
16741       // return back to the folder we came from initially (workaround)
16742
16743       if (chdir (cwd) == -1)
16744       {
16745         log_error ("ERROR: %s: %s", cwd, strerror (errno));
16746
16747         return -1;
16748       }
16749
16750       // some algorithm collide too fast, make that impossible
16751
16752       if (benchmark == 1)
16753       {
16754         ((uint *) digests_buf)[0] = -1;
16755         ((uint *) digests_buf)[1] = -1;
16756         ((uint *) digests_buf)[2] = -1;
16757         ((uint *) digests_buf)[3] = -1;
16758       }
16759
16760       /**
16761        * global buffers
16762        */
16763
16764       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL, &device_param->d_pws_buf);
16765       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_pws,     NULL, &device_param->d_pws_amp_buf);
16766       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_tmps,    NULL, &device_param->d_tmps);
16767       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_hooks,   NULL, &device_param->d_hooks);
16768       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s1_a);
16769       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s1_b);
16770       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s1_c);
16771       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s1_d);
16772       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s2_a);
16773       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s2_b);
16774       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s2_c);
16775       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   bitmap_size,  NULL, &device_param->d_bitmap_s2_d);
16776       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_plains,  NULL, &device_param->d_plain_bufs);
16777       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_digests, NULL, &device_param->d_digests_buf);
16778       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_shown,   NULL, &device_param->d_digests_shown);
16779       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY,   size_salts,   NULL, &device_param->d_salt_bufs);
16780       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_results, NULL, &device_param->d_result);
16781       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL, &device_param->d_scryptV0_buf);
16782       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL, &device_param->d_scryptV1_buf);
16783       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL, &device_param->d_scryptV2_buf);
16784       CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE,  size_scrypt4, NULL, &device_param->d_scryptV3_buf);
16785
16786       if (CL_err != CL_SUCCESS)
16787       {
16788         log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16789
16790         return -1;
16791       }
16792
16793       CL_err |= 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);
16794       CL_err |= 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);
16795       CL_err |= 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);
16796       CL_err |= 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);
16797       CL_err |= 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);
16798       CL_err |= 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);
16799       CL_err |= 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);
16800       CL_err |= 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);
16801       CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf,    CL_TRUE, 0, size_digests, data.digests_buf,   0, NULL, NULL);
16802       CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown,  CL_TRUE, 0, size_shown,   data.digests_shown, 0, NULL, NULL);
16803       CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs,      CL_TRUE, 0, size_salts,   data.salts_buf,     0, NULL, NULL);
16804
16805       if (CL_err != CL_SUCCESS)
16806       {
16807         log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16808
16809         return -1;
16810       }
16811
16812       /**
16813        * special buffers
16814        */
16815
16816       if (attack_kern == ATTACK_KERN_STRAIGHT)
16817       {
16818         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules,   NULL, &device_param->d_rules);
16819         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL, &device_param->d_rules_c);
16820
16821         if (CL_err != CL_SUCCESS)
16822         {
16823           log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16824
16825           return -1;
16826         }
16827
16828         CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16829
16830         if (CL_err != CL_SUCCESS)
16831         {
16832           log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16833
16834           return -1;
16835         }
16836       }
16837       else if (attack_kern == ATTACK_KERN_COMBI)
16838       {
16839         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL, &device_param->d_combs);
16840         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs,      NULL, &device_param->d_combs_c);
16841         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL, &device_param->d_root_css_buf);
16842         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16843
16844         if (CL_err != CL_SUCCESS)
16845         {
16846           log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16847
16848           return -1;
16849         }
16850       }
16851       else if (attack_kern == ATTACK_KERN_BF)
16852       {
16853         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL, &device_param->d_bfs);
16854         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs,        NULL, &device_param->d_bfs_c);
16855         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm,         NULL, &device_param->d_tm_c);
16856         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css,   NULL, &device_param->d_root_css_buf);
16857         CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16858
16859         if (CL_err != CL_SUCCESS)
16860         {
16861           log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16862
16863           return -1;
16864         }
16865       }
16866
16867       if (size_esalts)
16868       {
16869         CL_err = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL, &device_param->d_esalt_bufs);
16870
16871         if (CL_err != CL_SUCCESS)
16872         {
16873           log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16874
16875           return -1;
16876         }
16877
16878         CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16879
16880         if (CL_err != CL_SUCCESS)
16881         {
16882           log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16883
16884           return -1;
16885         }
16886       }
16887
16888       /**
16889        * main host data
16890        */
16891
16892       pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16893
16894       device_param->pws_buf = pws_buf;
16895
16896       comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16897
16898       device_param->combs_buf = combs_buf;
16899
16900       void *hooks_buf = mymalloc (size_hooks);
16901
16902       device_param->hooks_buf = hooks_buf;
16903
16904       /**
16905        * kernel args
16906        */
16907
16908       device_param->kernel_params_buf32[24] = bitmap_mask;
16909       device_param->kernel_params_buf32[25] = bitmap_shift1;
16910       device_param->kernel_params_buf32[26] = bitmap_shift2;
16911       device_param->kernel_params_buf32[27] = 0; // salt_pos
16912       device_param->kernel_params_buf32[28] = 0; // loop_pos
16913       device_param->kernel_params_buf32[29] = 0; // loop_cnt
16914       device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16915       device_param->kernel_params_buf32[31] = 0; // digests_cnt
16916       device_param->kernel_params_buf32[32] = 0; // digests_offset
16917       device_param->kernel_params_buf32[33] = 0; // combs_mode
16918       device_param->kernel_params_buf32[34] = 0; // gid_max
16919
16920       device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16921                                       ? &device_param->d_pws_buf
16922                                       : &device_param->d_pws_amp_buf;
16923       device_param->kernel_params[ 1] = &device_param->d_rules_c;
16924       device_param->kernel_params[ 2] = &device_param->d_combs_c;
16925       device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16926       device_param->kernel_params[ 4] = &device_param->d_tmps;
16927       device_param->kernel_params[ 5] = &device_param->d_hooks;
16928       device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16929       device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16930       device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16931       device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16932       device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16933       device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16934       device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16935       device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16936       device_param->kernel_params[14] = &device_param->d_plain_bufs;
16937       device_param->kernel_params[15] = &device_param->d_digests_buf;
16938       device_param->kernel_params[16] = &device_param->d_digests_shown;
16939       device_param->kernel_params[17] = &device_param->d_salt_bufs;
16940       device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16941       device_param->kernel_params[19] = &device_param->d_result;
16942       device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16943       device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16944       device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16945       device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16946       device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16947       device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16948       device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16949       device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16950       device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16951       device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16952       device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16953       device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16954       device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16955       device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16956       device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16957
16958       device_param->kernel_params_mp_buf64[3] = 0;
16959       device_param->kernel_params_mp_buf32[4] = 0;
16960       device_param->kernel_params_mp_buf32[5] = 0;
16961       device_param->kernel_params_mp_buf32[6] = 0;
16962       device_param->kernel_params_mp_buf32[7] = 0;
16963       device_param->kernel_params_mp_buf32[8] = 0;
16964
16965       device_param->kernel_params_mp[0] = NULL;
16966       device_param->kernel_params_mp[1] = NULL;
16967       device_param->kernel_params_mp[2] = NULL;
16968       device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16969       device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16970       device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16971       device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16972       device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16973       device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16974
16975       device_param->kernel_params_mp_l_buf64[3] = 0;
16976       device_param->kernel_params_mp_l_buf32[4] = 0;
16977       device_param->kernel_params_mp_l_buf32[5] = 0;
16978       device_param->kernel_params_mp_l_buf32[6] = 0;
16979       device_param->kernel_params_mp_l_buf32[7] = 0;
16980       device_param->kernel_params_mp_l_buf32[8] = 0;
16981       device_param->kernel_params_mp_l_buf32[9] = 0;
16982
16983       device_param->kernel_params_mp_l[0] = NULL;
16984       device_param->kernel_params_mp_l[1] = NULL;
16985       device_param->kernel_params_mp_l[2] = NULL;
16986       device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16987       device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16988       device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16989       device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16990       device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16991       device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16992       device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16993
16994       device_param->kernel_params_mp_r_buf64[3] = 0;
16995       device_param->kernel_params_mp_r_buf32[4] = 0;
16996       device_param->kernel_params_mp_r_buf32[5] = 0;
16997       device_param->kernel_params_mp_r_buf32[6] = 0;
16998       device_param->kernel_params_mp_r_buf32[7] = 0;
16999       device_param->kernel_params_mp_r_buf32[8] = 0;
17000
17001       device_param->kernel_params_mp_r[0] = NULL;
17002       device_param->kernel_params_mp_r[1] = NULL;
17003       device_param->kernel_params_mp_r[2] = NULL;
17004       device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
17005       device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
17006       device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
17007       device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
17008       device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
17009       device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
17010
17011       device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
17012       device_param->kernel_params_amp_buf32[6] = 0; // gid_max
17013
17014       device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
17015       device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
17016       device_param->kernel_params_amp[2] = &device_param->d_rules_c;
17017       device_param->kernel_params_amp[3] = &device_param->d_combs_c;
17018       device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
17019       device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
17020       device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
17021
17022       device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
17023       device_param->kernel_params_tm[1] = &device_param->d_tm_c;
17024
17025       device_param->kernel_params_memset_buf32[1] = 0; // value
17026       device_param->kernel_params_memset_buf32[2] = 0; // gid_max
17027
17028       device_param->kernel_params_memset[0] = NULL;
17029       device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
17030       device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
17031
17032       /**
17033        * kernel name
17034        */
17035
17036       size_t kernel_wgs_tmp;
17037
17038       char kernel_name[64] = { 0 };
17039
17040       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17041       {
17042         if (opti_type & OPTI_TYPE_SINGLE_HASH)
17043         {
17044           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
17045
17046           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17047
17048           if (CL_err != CL_SUCCESS)
17049           {
17050             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17051
17052             return -1;
17053           }
17054
17055           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
17056
17057           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17058
17059           if (CL_err != CL_SUCCESS)
17060           {
17061             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17062
17063             return -1;
17064           }
17065
17066           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
17067
17068           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17069
17070           if (CL_err != CL_SUCCESS)
17071           {
17072             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17073
17074             return -1;
17075           }
17076         }
17077         else
17078         {
17079           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
17080
17081           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17082
17083           if (CL_err != CL_SUCCESS)
17084           {
17085             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17086
17087             return -1;
17088           }
17089
17090           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
17091
17092           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17093
17094           if (CL_err != CL_SUCCESS)
17095           {
17096             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17097
17098             return -1;
17099           }
17100
17101           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
17102
17103           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17104
17105           if (CL_err != CL_SUCCESS)
17106           {
17107             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17108
17109             return -1;
17110           }
17111         }
17112
17113         if (data.attack_mode == ATTACK_MODE_BF)
17114         {
17115           if (opts_type & OPTS_TYPE_PT_BITSLICE)
17116           {
17117             snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
17118
17119             CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel_tm);
17120
17121             if (CL_err != CL_SUCCESS)
17122             {
17123               log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17124
17125               return -1;
17126             }
17127
17128             CL_err = 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);
17129
17130             if (CL_err != CL_SUCCESS)
17131             {
17132               log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17133
17134               return -1;
17135             }
17136           }
17137         }
17138       }
17139       else
17140       {
17141         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
17142
17143         CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17144
17145         if (CL_err != CL_SUCCESS)
17146         {
17147           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17148
17149           return -1;
17150         }
17151
17152         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
17153
17154         CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17155
17156         if (CL_err != CL_SUCCESS)
17157         {
17158           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17159
17160           return -1;
17161         }
17162
17163         snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
17164
17165         CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17166
17167         if (CL_err != CL_SUCCESS)
17168         {
17169           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17170
17171           return -1;
17172         }
17173
17174         if (opts_type & OPTS_TYPE_HOOK12)
17175         {
17176           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
17177
17178           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel12);
17179
17180           if (CL_err != CL_SUCCESS)
17181           {
17182             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17183
17184             return -1;
17185           }
17186
17187           CL_err = 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);
17188
17189           if (CL_err != CL_SUCCESS)
17190           {
17191             log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17192
17193             return -1;
17194           }
17195         }
17196
17197         if (opts_type & OPTS_TYPE_HOOK23)
17198         {
17199           snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
17200
17201           CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel23);
17202
17203           if (CL_err != CL_SUCCESS)
17204           {
17205             log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17206
17207             return -1;
17208           }
17209
17210           CL_err = 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);
17211
17212           if (CL_err != CL_SUCCESS)
17213           {
17214             log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17215
17216             return -1;
17217           }
17218         }
17219       }
17220
17221       CL_err |= 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);
17222       CL_err |= 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);
17223       CL_err |= 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);
17224
17225       if (CL_err != CL_SUCCESS)
17226       {
17227         log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17228
17229         return -1;
17230       }
17231
17232       for (uint i = 0; i <= 23; i++)
17233       {
17234         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
17235         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
17236         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
17237
17238         if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
17239         if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
17240
17241         if (CL_err != CL_SUCCESS)
17242         {
17243           log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17244
17245           return -1;
17246         }
17247       }
17248
17249       for (uint i = 24; i <= 34; i++)
17250       {
17251         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
17252         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
17253         CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
17254
17255         if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
17256         if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
17257
17258         if (CL_err != CL_SUCCESS)
17259         {
17260           log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17261
17262           return -1;
17263         }
17264       }
17265
17266       // GPU memset
17267
17268       CL_err = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset", &device_param->kernel_memset);
17269
17270       if (CL_err != CL_SUCCESS)
17271       {
17272         log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17273
17274         return -1;
17275       }
17276
17277       CL_err = 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);
17278
17279       if (CL_err != CL_SUCCESS)
17280       {
17281         log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17282
17283         return -1;
17284       }
17285
17286       CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem),  device_param->kernel_params_memset[0]);
17287       CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
17288       CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
17289
17290       if (CL_err != CL_SUCCESS)
17291       {
17292         log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17293
17294         return -1;
17295       }
17296
17297       // MP start
17298
17299       if (attack_mode == ATTACK_MODE_BF)
17300       {
17301         CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov", &device_param->kernel_mp_l);
17302         CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov", &device_param->kernel_mp_r);
17303
17304         if (CL_err != CL_SUCCESS)
17305         {
17306           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17307
17308           return -1;
17309         }
17310
17311         CL_err |= 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);
17312         CL_err |= 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);
17313
17314         if (CL_err != CL_SUCCESS)
17315         {
17316           log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17317
17318           return -1;
17319         }
17320
17321         if (opts_type & OPTS_TYPE_PT_BITSLICE)
17322         {
17323           CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
17324           CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
17325
17326           if (CL_err != CL_SUCCESS)
17327           {
17328             log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17329
17330             return -1;
17331           }
17332         }
17333       }
17334       else if (attack_mode == ATTACK_MODE_HYBRID1)
17335       {
17336         CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17337
17338         if (CL_err != CL_SUCCESS)
17339         {
17340           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17341
17342           return -1;
17343         }
17344
17345         CL_err = 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);
17346
17347         if (CL_err != CL_SUCCESS)
17348         {
17349           log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17350
17351           return -1;
17352         }
17353       }
17354       else if (attack_mode == ATTACK_MODE_HYBRID2)
17355       {
17356         CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17357
17358         if (CL_err != CL_SUCCESS)
17359         {
17360           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17361
17362           return -1;
17363         }
17364
17365         CL_err = 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);
17366
17367         if (CL_err != CL_SUCCESS)
17368         {
17369           log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17370
17371           return -1;
17372         }
17373       }
17374
17375       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17376       {
17377         // nothing to do
17378       }
17379       else
17380       {
17381         CL_err = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp", &device_param->kernel_amp);
17382
17383         if (CL_err != CL_SUCCESS)
17384         {
17385           log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17386
17387           return -1;
17388         }
17389
17390         CL_err = 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);
17391
17392         if (CL_err != CL_SUCCESS)
17393         {
17394           log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17395
17396           return -1;
17397         }
17398       }
17399
17400       if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17401       {
17402         // nothing to do
17403       }
17404       else
17405       {
17406         for (uint i = 0; i < 5; i++)
17407         {
17408           CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
17409
17410           if (CL_err != CL_SUCCESS)
17411           {
17412             log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17413
17414             return -1;
17415           }
17416         }
17417
17418         for (uint i = 5; i < 7; i++)
17419         {
17420           CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
17421
17422           if (CL_err != CL_SUCCESS)
17423           {
17424             log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17425
17426             return -1;
17427           }
17428         }
17429       }
17430
17431       // maybe this has been updated by clGetKernelWorkGroupInfo()
17432       // value can only be decreased, so we don't need to reallocate buffers
17433
17434       device_param->kernel_threads = kernel_threads;
17435
17436       // zero some data buffers
17437
17438       run_kernel_bzero (device_param, device_param->d_pws_buf,        size_pws);
17439       run_kernel_bzero (device_param, device_param->d_pws_amp_buf,    size_pws);
17440       run_kernel_bzero (device_param, device_param->d_tmps,           size_tmps);
17441       run_kernel_bzero (device_param, device_param->d_hooks,          size_hooks);
17442       run_kernel_bzero (device_param, device_param->d_plain_bufs,     size_plains);
17443       run_kernel_bzero (device_param, device_param->d_result,         size_results);
17444
17445       /**
17446        * special buffers
17447        */
17448
17449       if (attack_kern == ATTACK_KERN_STRAIGHT)
17450       {
17451         run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
17452       }
17453       else if (attack_kern == ATTACK_KERN_COMBI)
17454       {
17455         run_kernel_bzero (device_param, device_param->d_combs,          size_combs);
17456         run_kernel_bzero (device_param, device_param->d_combs_c,        size_combs);
17457         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
17458         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17459       }
17460       else if (attack_kern == ATTACK_KERN_BF)
17461       {
17462         run_kernel_bzero (device_param, device_param->d_bfs,            size_bfs);
17463         run_kernel_bzero (device_param, device_param->d_bfs_c,          size_bfs);
17464         run_kernel_bzero (device_param, device_param->d_tm_c,           size_tm);
17465         run_kernel_bzero (device_param, device_param->d_root_css_buf,   size_root_css);
17466         run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17467       }
17468
17469       #if defined(HAVE_HWMON)
17470
17471       /**
17472        * Store initial fanspeed if gpu_temp_retain is enabled
17473        */
17474
17475       if (gpu_temp_disable == 0)
17476       {
17477         if (gpu_temp_retain != 0)
17478         {
17479           hc_thread_mutex_lock (mux_adl);
17480
17481           if (data.hm_device[device_id].fan_get_supported == 1)
17482           {
17483             const int fanspeed  = hm_get_fanspeed_with_device_id  (device_id);
17484             const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
17485
17486             // we also set it to tell the OS we take control over the fan and it's automatic controller
17487             // if it was set to automatic. we do not control user-defined fanspeeds.
17488
17489             if (fanpolicy == 1)
17490             {
17491               data.hm_device[device_id].fan_set_supported = 1;
17492
17493               int rc = -1;
17494
17495               if (device_param->device_vendor_id == VENDOR_ID_AMD)
17496               {
17497                 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
17498               }
17499               else if (device_param->device_vendor_id == VENDOR_ID_NV)
17500               {
17501                 #ifdef __linux__
17502                 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
17503                 #endif
17504
17505                 #ifdef WIN
17506                 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
17507                 #endif
17508               }
17509
17510               if (rc == 0)
17511               {
17512                 data.hm_device[device_id].fan_set_supported = 1;
17513               }
17514               else
17515               {
17516                 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
17517
17518                 data.hm_device[device_id].fan_set_supported = 0;
17519               }
17520             }
17521             else
17522             {
17523               data.hm_device[device_id].fan_set_supported = 0;
17524             }
17525           }
17526
17527           hc_thread_mutex_unlock (mux_adl);
17528         }
17529       }
17530
17531       #endif // HAVE_HWMON
17532     }
17533
17534     if (data.quiet == 0) log_info_nn ("");
17535
17536     /**
17537      * In benchmark-mode, inform user which algorithm is checked
17538      */
17539
17540     if (benchmark == 1)
17541     {
17542       if (machine_readable == 0)
17543       {
17544         quiet = 0;
17545
17546         data.quiet = quiet;
17547
17548         char *hash_type = strhashtype (data.hash_mode); // not a bug
17549
17550         log_info ("Hashtype: %s", hash_type);
17551         log_info ("");
17552       }
17553     }
17554
17555     /**
17556      * keep track of the progress
17557      */
17558
17559     data.words_progress_done     = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17560     data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17561     data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17562
17563     /**
17564      * open filehandles
17565      */
17566
17567     #if _WIN
17568     if (_setmode (_fileno (stdin), _O_BINARY) == -1)
17569     {
17570       log_error ("ERROR: %s: %s", "stdin", strerror (errno));
17571
17572       return -1;
17573     }
17574
17575     if (_setmode (_fileno (stdout), _O_BINARY) == -1)
17576     {
17577       log_error ("ERROR: %s: %s", "stdout", strerror (errno));
17578
17579       return -1;
17580     }
17581
17582     if (_setmode (_fileno (stderr), _O_BINARY) == -1)
17583     {
17584       log_error ("ERROR: %s: %s", "stderr", strerror (errno));
17585
17586       return -1;
17587     }
17588     #endif
17589
17590     /**
17591      * dictionary pad
17592      */
17593
17594     segment_size *= (1024 * 1024);
17595
17596     data.segment_size = segment_size;
17597
17598     wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
17599
17600     wl_data->buf   = (char *) mymalloc (segment_size);
17601     wl_data->avail = segment_size;
17602     wl_data->incr  = segment_size;
17603     wl_data->cnt   = 0;
17604     wl_data->pos   = 0;
17605
17606     cs_t  *css_buf   = NULL;
17607     uint   css_cnt   = 0;
17608     uint   dictcnt   = 0;
17609     uint   maskcnt   = 1;
17610     char **masks     = NULL;
17611     char **dictfiles = NULL;
17612
17613     uint   mask_from_file = 0;
17614
17615     if (attack_mode == ATTACK_MODE_STRAIGHT)
17616     {
17617       if (wordlist_mode == WL_MODE_FILE)
17618       {
17619         int wls_left = myargc - (optind + 1);
17620
17621         for (int i = 0; i < wls_left; i++)
17622         {
17623           char *l0_filename = myargv[optind + 1 + i];
17624
17625           struct stat l0_stat;
17626
17627           if (stat (l0_filename, &l0_stat) == -1)
17628           {
17629             log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
17630
17631             return -1;
17632           }
17633
17634           uint is_dir = S_ISDIR (l0_stat.st_mode);
17635
17636           if (is_dir == 0)
17637           {
17638             dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17639
17640             dictcnt++;
17641
17642             dictfiles[dictcnt - 1] = l0_filename;
17643           }
17644           else
17645           {
17646             // do not allow --keyspace w/ a directory
17647
17648             if (keyspace == 1)
17649             {
17650               log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17651
17652               return -1;
17653             }
17654
17655             char **dictionary_files = NULL;
17656
17657             dictionary_files = scan_directory (l0_filename);
17658
17659             if (dictionary_files != NULL)
17660             {
17661               qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17662
17663               for (int d = 0; dictionary_files[d] != NULL; d++)
17664               {
17665                 char *l1_filename = dictionary_files[d];
17666
17667                 struct stat l1_stat;
17668
17669                 if (stat (l1_filename, &l1_stat) == -1)
17670                 {
17671                   log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17672
17673                   return -1;
17674                 }
17675
17676                 if (S_ISREG (l1_stat.st_mode))
17677                 {
17678                   dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17679
17680                   dictcnt++;
17681
17682                   dictfiles[dictcnt - 1] = strdup (l1_filename);
17683                 }
17684               }
17685             }
17686
17687             local_free (dictionary_files);
17688           }
17689         }
17690
17691         if (dictcnt < 1)
17692         {
17693           log_error ("ERROR: No usable dictionary file found.");
17694
17695           return -1;
17696         }
17697       }
17698       else if (wordlist_mode == WL_MODE_STDIN)
17699       {
17700         dictcnt = 1;
17701       }
17702     }
17703     else if (attack_mode == ATTACK_MODE_COMBI)
17704     {
17705       // display
17706
17707       char *dictfile1 = myargv[optind + 1 + 0];
17708       char *dictfile2 = myargv[optind + 1 + 1];
17709
17710       // find the bigger dictionary and use as base
17711
17712       FILE *fp1 = NULL;
17713       FILE *fp2 = NULL;
17714
17715       struct stat tmp_stat;
17716
17717       if ((fp1 = fopen (dictfile1, "rb")) == NULL)
17718       {
17719         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17720
17721         return -1;
17722       }
17723
17724       if (stat (dictfile1, &tmp_stat) == -1)
17725       {
17726         log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17727
17728         fclose (fp1);
17729
17730         return -1;
17731       }
17732
17733       if (S_ISDIR (tmp_stat.st_mode))
17734       {
17735         log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
17736
17737         fclose (fp1);
17738
17739         return -1;
17740       }
17741
17742       if ((fp2 = fopen (dictfile2, "rb")) == NULL)
17743       {
17744         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17745
17746         fclose (fp1);
17747
17748         return -1;
17749       }
17750
17751       if (stat (dictfile2, &tmp_stat) == -1)
17752       {
17753         log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17754
17755         fclose (fp1);
17756         fclose (fp2);
17757
17758         return -1;
17759       }
17760
17761       if (S_ISDIR (tmp_stat.st_mode))
17762       {
17763         log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
17764
17765         fclose (fp1);
17766         fclose (fp2);
17767
17768         return -1;
17769       }
17770
17771       data.combs_cnt = 1;
17772
17773       data.quiet = 1;
17774
17775       const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
17776
17777       data.quiet = quiet;
17778
17779       if (words1_cnt == 0)
17780       {
17781         log_error ("ERROR: %s: empty file", dictfile1);
17782
17783         fclose (fp1);
17784         fclose (fp2);
17785
17786         return -1;
17787       }
17788
17789       data.combs_cnt = 1;
17790
17791       data.quiet = 1;
17792
17793       const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
17794
17795       data.quiet = quiet;
17796
17797       if (words2_cnt == 0)
17798       {
17799         log_error ("ERROR: %s: empty file", dictfile2);
17800
17801         fclose (fp1);
17802         fclose (fp2);
17803
17804         return -1;
17805       }
17806
17807       fclose (fp1);
17808       fclose (fp2);
17809
17810       data.dictfile  = dictfile1;
17811       data.dictfile2 = dictfile2;
17812
17813       if (words1_cnt >= words2_cnt)
17814       {
17815         data.combs_cnt  = words2_cnt;
17816         data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
17817
17818         dictfiles = &data.dictfile;
17819
17820         dictcnt = 1;
17821       }
17822       else
17823       {
17824         data.combs_cnt  = words1_cnt;
17825         data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17826
17827         dictfiles = &data.dictfile2;
17828
17829         dictcnt = 1;
17830
17831         // we also have to switch wordlist related rules!
17832
17833         char *tmpc = data.rule_buf_l;
17834
17835         data.rule_buf_l = data.rule_buf_r;
17836         data.rule_buf_r = tmpc;
17837
17838         int   tmpi = data.rule_len_l;
17839
17840         data.rule_len_l = data.rule_len_r;
17841         data.rule_len_r = tmpi;
17842       }
17843     }
17844     else if (attack_mode == ATTACK_MODE_BF)
17845     {
17846       char *mask = NULL;
17847
17848       maskcnt = 0;
17849
17850       if (benchmark == 0)
17851       {
17852         mask = myargv[optind + 1];
17853
17854         masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
17855
17856         if ((optind + 2) <= myargc)
17857         {
17858           struct stat file_stat;
17859
17860           if (stat (mask, &file_stat) == -1)
17861           {
17862             maskcnt = 1;
17863
17864             masks[maskcnt - 1] = mystrdup (mask);
17865           }
17866           else
17867           {
17868             int wls_left = myargc - (optind + 1);
17869
17870             uint masks_avail = INCR_MASKS;
17871
17872             for (int i = 0; i < wls_left; i++)
17873             {
17874               if (i != 0)
17875               {
17876                 mask = myargv[optind + 1 + i];
17877
17878                 if (stat (mask, &file_stat) == -1)
17879                 {
17880                   log_error ("ERROR: %s: %s", mask, strerror (errno));
17881
17882                   return -1;
17883                 }
17884               }
17885
17886               uint is_file = S_ISREG (file_stat.st_mode);
17887
17888               if (is_file == 1)
17889               {
17890                 FILE *mask_fp;
17891
17892                 if ((mask_fp = fopen (mask, "r")) == NULL)
17893                 {
17894                   log_error ("ERROR: %s: %s", mask, strerror (errno));
17895
17896                   return -1;
17897                 }
17898
17899                 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17900
17901                 while (!feof (mask_fp))
17902                 {
17903                   memset (line_buf, 0, HCBUFSIZ);
17904
17905                   int line_len = fgetl (mask_fp, line_buf);
17906
17907                   if (line_len == 0) continue;
17908
17909                   if (line_buf[0] == '#') continue;
17910
17911                   if (masks_avail == maskcnt)
17912                   {
17913                     masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17914
17915                     masks_avail += INCR_MASKS;
17916                   }
17917
17918                   masks[maskcnt] = mystrdup (line_buf);
17919
17920                   maskcnt++;
17921                 }
17922
17923                 myfree (line_buf);
17924
17925                 fclose (mask_fp);
17926               }
17927               else
17928               {
17929                 log_error ("ERROR: %s: unsupported file-type", mask);
17930
17931                 return -1;
17932               }
17933             }
17934
17935             mask_from_file = 1;
17936           }
17937         }
17938         else
17939         {
17940           custom_charset_1 = (char *) "?l?d?u";
17941           custom_charset_2 = (char *) "?l?d";
17942           custom_charset_3 = (char *) "?l?d*!$@_";
17943
17944           mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17945           mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17946           mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17947
17948           masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
17949
17950           wordlist_mode = WL_MODE_MASK;
17951
17952           data.wordlist_mode = wordlist_mode;
17953
17954           increment = 1;
17955
17956           maskcnt   = 1;
17957         }
17958       }
17959       else
17960       {
17961         /**
17962          * generate full masks and charsets
17963          */
17964
17965         masks = (char **) mymalloc (sizeof (char *));
17966
17967         switch (hash_mode)
17968         {
17969           case  1731: pw_min = 5;
17970                       pw_max = 5;
17971                       mask = mystrdup ("?b?b?b?b?b");
17972                       break;
17973           case 12500: pw_min = 5;
17974                       pw_max = 5;
17975                       mask = mystrdup ("?b?b?b?b?b");
17976                       break;
17977           default:    pw_min = 7;
17978                       pw_max = 7;
17979                       mask = mystrdup ("?b?b?b?b?b?b?b");
17980                       break;
17981         }
17982
17983         maskcnt = 1;
17984
17985         masks[maskcnt - 1] = mystrdup (mask);
17986
17987         wordlist_mode = WL_MODE_MASK;
17988
17989         data.wordlist_mode = wordlist_mode;
17990
17991         increment = 1;
17992       }
17993
17994       dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
17995
17996       if (increment)
17997       {
17998         if (increment_min > pw_min) pw_min = increment_min;
17999
18000         if (increment_max < pw_max) pw_max = increment_max;
18001       }
18002     }
18003     else if (attack_mode == ATTACK_MODE_HYBRID1)
18004     {
18005       data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
18006
18007       // display
18008
18009       char *mask = myargv[myargc - 1];
18010
18011       maskcnt = 0;
18012
18013       masks = (char **) mymalloc (1 * sizeof (char *));
18014
18015       // mod
18016
18017       struct stat file_stat;
18018
18019       if (stat (mask, &file_stat) == -1)
18020       {
18021         maskcnt = 1;
18022
18023         masks[maskcnt - 1] = mystrdup (mask);
18024       }
18025       else
18026       {
18027         uint is_file = S_ISREG (file_stat.st_mode);
18028
18029         if (is_file == 1)
18030         {
18031           FILE *mask_fp;
18032
18033           if ((mask_fp = fopen (mask, "r")) == NULL)
18034           {
18035             log_error ("ERROR: %s: %s", mask, strerror (errno));
18036
18037             return -1;
18038           }
18039
18040           char *line_buf = (char *) mymalloc (HCBUFSIZ);
18041
18042           uint masks_avail = 1;
18043
18044           while (!feof (mask_fp))
18045           {
18046             memset (line_buf, 0, HCBUFSIZ);
18047
18048             int line_len = fgetl (mask_fp, line_buf);
18049
18050             if (line_len == 0) continue;
18051
18052             if (line_buf[0] == '#') continue;
18053
18054             if (masks_avail == maskcnt)
18055             {
18056               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18057
18058               masks_avail += INCR_MASKS;
18059             }
18060
18061             masks[maskcnt] = mystrdup (line_buf);
18062
18063             maskcnt++;
18064           }
18065
18066           myfree (line_buf);
18067
18068           fclose (mask_fp);
18069
18070           mask_from_file = 1;
18071         }
18072         else
18073         {
18074           maskcnt = 1;
18075
18076           masks[maskcnt - 1] = mystrdup (mask);
18077         }
18078       }
18079
18080       // base
18081
18082       int wls_left = myargc - (optind + 2);
18083
18084       for (int i = 0; i < wls_left; i++)
18085       {
18086         char *filename = myargv[optind + 1 + i];
18087
18088         struct stat file_stat;
18089
18090         if (stat (filename, &file_stat) == -1)
18091         {
18092           log_error ("ERROR: %s: %s", filename, strerror (errno));
18093
18094           return -1;
18095         }
18096
18097         uint is_dir = S_ISDIR (file_stat.st_mode);
18098
18099         if (is_dir == 0)
18100         {
18101           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18102
18103           dictcnt++;
18104
18105           dictfiles[dictcnt - 1] = filename;
18106         }
18107         else
18108         {
18109           // do not allow --keyspace w/ a directory
18110
18111           if (keyspace == 1)
18112           {
18113             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18114
18115             return -1;
18116           }
18117
18118           char **dictionary_files = NULL;
18119
18120           dictionary_files = scan_directory (filename);
18121
18122           if (dictionary_files != NULL)
18123           {
18124             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18125
18126             for (int d = 0; dictionary_files[d] != NULL; d++)
18127             {
18128               char *l1_filename = dictionary_files[d];
18129
18130               struct stat l1_stat;
18131
18132               if (stat (l1_filename, &l1_stat) == -1)
18133               {
18134                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18135
18136                 return -1;
18137               }
18138
18139               if (S_ISREG (l1_stat.st_mode))
18140               {
18141                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18142
18143                 dictcnt++;
18144
18145                 dictfiles[dictcnt - 1] = strdup (l1_filename);
18146               }
18147             }
18148           }
18149
18150           local_free (dictionary_files);
18151         }
18152       }
18153
18154       if (dictcnt < 1)
18155       {
18156         log_error ("ERROR: No usable dictionary file found.");
18157
18158         return -1;
18159       }
18160
18161       if (increment)
18162       {
18163         maskcnt = 0;
18164
18165         uint mask_min = increment_min; // we can't reject smaller masks here
18166         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18167
18168         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18169         {
18170           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18171
18172           if (cur_mask == NULL) break;
18173
18174           masks[maskcnt] = cur_mask;
18175
18176           maskcnt++;
18177
18178           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18179         }
18180       }
18181     }
18182     else if (attack_mode == ATTACK_MODE_HYBRID2)
18183     {
18184       data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
18185
18186       // display
18187
18188       char *mask = myargv[optind + 1 + 0];
18189
18190       maskcnt = 0;
18191
18192       masks = (char **) mymalloc (1 * sizeof (char *));
18193
18194       // mod
18195
18196       struct stat file_stat;
18197
18198       if (stat (mask, &file_stat) == -1)
18199       {
18200         maskcnt = 1;
18201
18202         masks[maskcnt - 1] = mystrdup (mask);
18203       }
18204       else
18205       {
18206         uint is_file = S_ISREG (file_stat.st_mode);
18207
18208         if (is_file == 1)
18209         {
18210           FILE *mask_fp;
18211
18212           if ((mask_fp = fopen (mask, "r")) == NULL)
18213           {
18214             log_error ("ERROR: %s: %s", mask, strerror (errno));
18215
18216             return -1;
18217           }
18218
18219           char *line_buf = (char *) mymalloc (HCBUFSIZ);
18220
18221           uint masks_avail = 1;
18222
18223           while (!feof (mask_fp))
18224           {
18225             memset (line_buf, 0, HCBUFSIZ);
18226
18227             int line_len = fgetl (mask_fp, line_buf);
18228
18229             if (line_len == 0) continue;
18230
18231             if (line_buf[0] == '#') continue;
18232
18233             if (masks_avail == maskcnt)
18234             {
18235               masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18236
18237               masks_avail += INCR_MASKS;
18238             }
18239
18240             masks[maskcnt] = mystrdup (line_buf);
18241
18242             maskcnt++;
18243           }
18244
18245           myfree (line_buf);
18246
18247           fclose (mask_fp);
18248
18249           mask_from_file = 1;
18250         }
18251         else
18252         {
18253           maskcnt = 1;
18254
18255           masks[maskcnt - 1] = mystrdup (mask);
18256         }
18257       }
18258
18259       // base
18260
18261       int wls_left = myargc - (optind + 2);
18262
18263       for (int i = 0; i < wls_left; i++)
18264       {
18265         char *filename = myargv[optind + 2 + i];
18266
18267         struct stat file_stat;
18268
18269         if (stat (filename, &file_stat) == -1)
18270         {
18271           log_error ("ERROR: %s: %s", filename, strerror (errno));
18272
18273           return -1;
18274         }
18275
18276         uint is_dir = S_ISDIR (file_stat.st_mode);
18277
18278         if (is_dir == 0)
18279         {
18280           dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18281
18282           dictcnt++;
18283
18284           dictfiles[dictcnt - 1] = filename;
18285         }
18286         else
18287         {
18288           // do not allow --keyspace w/ a directory
18289
18290           if (keyspace == 1)
18291           {
18292             log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18293
18294             return -1;
18295           }
18296
18297           char **dictionary_files = NULL;
18298
18299           dictionary_files = scan_directory (filename);
18300
18301           if (dictionary_files != NULL)
18302           {
18303             qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18304
18305             for (int d = 0; dictionary_files[d] != NULL; d++)
18306             {
18307               char *l1_filename = dictionary_files[d];
18308
18309               struct stat l1_stat;
18310
18311               if (stat (l1_filename, &l1_stat) == -1)
18312               {
18313                 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18314
18315                 return -1;
18316               }
18317
18318               if (S_ISREG (l1_stat.st_mode))
18319               {
18320                 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18321
18322                 dictcnt++;
18323
18324                 dictfiles[dictcnt - 1] = strdup (l1_filename);
18325               }
18326             }
18327           }
18328
18329           local_free (dictionary_files);
18330         }
18331       }
18332
18333       if (dictcnt < 1)
18334       {
18335         log_error ("ERROR: No usable dictionary file found.");
18336
18337         return -1;
18338       }
18339
18340       if (increment)
18341       {
18342         maskcnt = 0;
18343
18344         uint mask_min = increment_min; // we can't reject smaller masks here
18345         uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18346
18347         for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18348         {
18349           char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18350
18351           if (cur_mask == NULL) break;
18352
18353           masks[maskcnt] = cur_mask;
18354
18355           maskcnt++;
18356
18357           masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18358         }
18359       }
18360     }
18361
18362     data.pw_min = pw_min;
18363     data.pw_max = pw_max;
18364
18365     /**
18366      * weak hash check
18367      */
18368
18369     if (weak_hash_threshold >= salts_cnt)
18370     {
18371       hc_device_param_t *device_param = NULL;
18372
18373       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18374       {
18375         device_param = &data.devices_param[device_id];
18376
18377         if (device_param->skipped) continue;
18378
18379         break;
18380       }
18381
18382       if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
18383
18384       for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
18385       {
18386         weak_hash_check (device_param, salt_pos);
18387       }
18388
18389       // Display hack, guarantee that there is at least one \r before real start
18390
18391       //if (data.quiet == 0) log_info ("");
18392     }
18393
18394     /**
18395      * status and monitor threads
18396      */
18397
18398     if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18399     {
18400       data.devices_status = STATUS_STARTING;
18401     }
18402
18403     uint inner_threads_cnt = 0;
18404
18405     hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
18406
18407     data.shutdown_inner = 0;
18408
18409     /**
18410       * Outfile remove
18411       */
18412
18413     if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
18414     {
18415       hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
18416
18417       inner_threads_cnt++;
18418
18419       if (outfile_check_timer != 0)
18420       {
18421         if (data.outfile_check_directory != NULL)
18422         {
18423           if ((hash_mode != 5200) &&
18424               !((hash_mode >=  6200) && (hash_mode <=  6299)) &&
18425               !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
18426               (hash_mode != 9000))
18427           {
18428             hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
18429
18430             inner_threads_cnt++;
18431           }
18432           else
18433           {
18434             outfile_check_timer = 0;
18435           }
18436         }
18437         else
18438         {
18439           outfile_check_timer = 0;
18440         }
18441       }
18442     }
18443
18444     /**
18445      * Inform the user if we got some hashes remove because of the pot file remove feature
18446      */
18447
18448     if (data.quiet == 0)
18449     {
18450       if (potfile_remove_cracks > 0)
18451       {
18452         if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
18453         else                            log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
18454       }
18455     }
18456
18457     data.outfile_check_timer = outfile_check_timer;
18458
18459     /**
18460      * main loop
18461      */
18462
18463     char **induction_dictionaries = NULL;
18464
18465     int induction_dictionaries_cnt = 0;
18466
18467     hcstat_table_t *root_table_buf   = NULL;
18468     hcstat_table_t *markov_table_buf = NULL;
18469
18470     uint initial_restore_done = 0;
18471
18472     data.maskcnt = maskcnt;
18473
18474     for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
18475     {
18476       if (data.devices_status == STATUS_CRACKED) continue;
18477       if (data.devices_status == STATUS_ABORTED) continue;
18478       if (data.devices_status == STATUS_QUIT)    continue;
18479
18480       if (maskpos > rd->maskpos)
18481       {
18482         rd->dictpos = 0;
18483       }
18484
18485       rd->maskpos  = maskpos;
18486       data.maskpos = maskpos;
18487
18488       if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
18489       {
18490         char *mask = masks[maskpos];
18491
18492         if (mask_from_file == 1)
18493         {
18494           if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
18495
18496           char *str_ptr;
18497           uint  str_pos;
18498
18499           uint mask_offset = 0;
18500
18501           uint separator_cnt;
18502
18503           for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
18504           {
18505             str_ptr = strstr (mask + mask_offset, ",");
18506
18507             if (str_ptr == NULL) break;
18508
18509             str_pos = str_ptr - mask;
18510
18511             // escaped separator, i.e. "\,"
18512
18513             if (str_pos > 0)
18514             {
18515               if (mask[str_pos - 1] == '\\')
18516               {
18517                 separator_cnt --;
18518
18519                 mask_offset = str_pos + 1;
18520
18521                 continue;
18522               }
18523             }
18524
18525             // reset the offset
18526
18527             mask_offset = 0;
18528
18529             mask[str_pos] = '\0';
18530
18531             switch (separator_cnt)
18532             {
18533               case 0:
18534                 mp_reset_usr (mp_usr, 0);
18535
18536                 custom_charset_1 = mask;
18537                 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
18538                 break;
18539
18540               case 1:
18541                 mp_reset_usr (mp_usr, 1);
18542
18543                 custom_charset_2 = mask;
18544                 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
18545                 break;
18546
18547               case 2:
18548                 mp_reset_usr (mp_usr, 2);
18549
18550                 custom_charset_3 = mask;
18551                 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
18552                 break;
18553
18554               case 3:
18555                 mp_reset_usr (mp_usr, 3);
18556
18557                 custom_charset_4 = mask;
18558                 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
18559                 break;
18560             }
18561
18562             mask = mask + str_pos + 1;
18563           }
18564
18565           /**
18566            * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
18567            * it would be interpreted as a custom charset definition.
18568            *
18569            * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
18570            * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
18571            */
18572
18573           uint mask_len_cur = strlen (mask);
18574
18575           uint mask_out_pos = 0;
18576           char mask_prev = 0;
18577
18578           for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
18579           {
18580             if (mask[mask_iter] == ',')
18581             {
18582               if (mask_prev == '\\')
18583               {
18584                 mask_out_pos -= 1; // this means: skip the previous "\"
18585               }
18586             }
18587
18588             mask_prev = mask[mask_iter];
18589
18590             mask[mask_out_pos] = mask[mask_iter];
18591           }
18592
18593           mask[mask_out_pos] = '\0';
18594         }
18595
18596         if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18597         {
18598           if (maskpos > 0)
18599           {
18600             local_free (css_buf);
18601             local_free (data.root_css_buf);
18602             local_free (data.markov_css_buf);
18603
18604             local_free (masks[maskpos - 1]);
18605           }
18606
18607           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18608
18609           data.mask = mask;
18610           data.css_cnt = css_cnt;
18611           data.css_buf = css_buf;
18612
18613           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18614
18615           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18616
18617           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
18618           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18619
18620           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18621
18622           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18623
18624           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
18625           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18626
18627           data.root_css_buf   = root_css_buf;
18628           data.markov_css_buf = markov_css_buf;
18629
18630           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18631
18632           data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18633
18634           local_free (root_table_buf);
18635           local_free (markov_table_buf);
18636
18637           // args
18638
18639           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18640           {
18641             hc_device_param_t *device_param = &data.devices_param[device_id];
18642
18643             if (device_param->skipped) continue;
18644
18645             device_param->kernel_params_mp[0] = &device_param->d_combs;
18646             device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
18647             device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
18648
18649             device_param->kernel_params_mp_buf64[3] = 0;
18650             device_param->kernel_params_mp_buf32[4] = css_cnt;
18651             device_param->kernel_params_mp_buf32[5] = 0;
18652             device_param->kernel_params_mp_buf32[6] = 0;
18653             device_param->kernel_params_mp_buf32[7] = 0;
18654
18655             if (attack_mode == ATTACK_MODE_HYBRID1)
18656             {
18657               if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_buf32[5] = full01;
18658               if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_buf32[5] = full80;
18659               if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
18660               if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
18661             }
18662             else if (attack_mode == ATTACK_MODE_HYBRID2)
18663             {
18664               device_param->kernel_params_mp_buf32[5] = 0;
18665               device_param->kernel_params_mp_buf32[6] = 0;
18666               device_param->kernel_params_mp_buf32[7] = 0;
18667             }
18668
18669             cl_int CL_err = CL_SUCCESS;
18670
18671             for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp[i]);
18672             for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
18673             for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp[i]);
18674
18675             if (CL_err != CL_SUCCESS)
18676             {
18677               log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
18678
18679               return -1;
18680             }
18681
18682             CL_err |= 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);
18683             CL_err |= 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);
18684
18685             if (CL_err != CL_SUCCESS)
18686             {
18687               log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
18688
18689               return -1;
18690             }
18691           }
18692         }
18693         else if (attack_mode == ATTACK_MODE_BF)
18694         {
18695           dictcnt = 0;  // number of "sub-masks", i.e. when using incremental mode
18696
18697           if (increment)
18698           {
18699             for (uint i = 0; i < dictcnt; i++)
18700             {
18701               local_free (dictfiles[i]);
18702             }
18703
18704             for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
18705             {
18706               char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
18707
18708               if (l1_filename == NULL) break;
18709
18710               dictcnt++;
18711
18712               dictfiles[dictcnt - 1] = l1_filename;
18713             }
18714           }
18715           else
18716           {
18717             dictcnt++;
18718
18719             dictfiles[dictcnt - 1] = mask;
18720           }
18721
18722           if (dictcnt == 0)
18723           {
18724             log_error ("ERROR: Mask is too small");
18725
18726             return -1;
18727           }
18728         }
18729       }
18730
18731       free (induction_dictionaries);
18732
18733       // induction_dictionaries_cnt = 0; // implied
18734
18735       if (attack_mode != ATTACK_MODE_BF)
18736       {
18737         if (keyspace == 0)
18738         {
18739           induction_dictionaries = scan_directory (induction_directory);
18740
18741           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18742         }
18743       }
18744
18745       if (induction_dictionaries_cnt)
18746       {
18747         qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18748       }
18749
18750       /**
18751        * prevent the user from using --keyspace together w/ maskfile and or dictfile
18752        */
18753       if (keyspace == 1)
18754       {
18755         if ((maskcnt > 1) || (dictcnt > 1))
18756         {
18757           log_error ("ERROR: --keyspace is not supported with --increment or mask files");
18758
18759           return -1;
18760         }
18761       }
18762
18763       for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
18764       {
18765         if (data.devices_status == STATUS_CRACKED) continue;
18766         if (data.devices_status == STATUS_ABORTED) continue;
18767         if (data.devices_status == STATUS_QUIT)    continue;
18768
18769         rd->dictpos = dictpos;
18770
18771         char *subid = logfile_generate_subid ();
18772
18773         data.subid = subid;
18774
18775         logfile_sub_msg ("START");
18776
18777         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18778         {
18779           data.devices_status = STATUS_INIT;
18780         }
18781
18782         memset (data.words_progress_done,     0, data.salts_cnt * sizeof (u64));
18783         memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
18784         memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
18785
18786         memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
18787
18788         data.cpt_pos = 0;
18789
18790         data.cpt_start = time (NULL);
18791
18792         data.cpt_total = 0;
18793
18794         if (data.restore == 0)
18795         {
18796           rd->words_cur = skip;
18797
18798           skip = 0;
18799
18800           data.skip = 0;
18801         }
18802
18803         data.ms_paused = 0;
18804
18805         data.kernel_power_final = 0;
18806
18807         data.words_cur = rd->words_cur;
18808
18809         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18810         {
18811           hc_device_param_t *device_param = &data.devices_param[device_id];
18812
18813           if (device_param->skipped) continue;
18814
18815           device_param->speed_pos = 0;
18816
18817           memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
18818           memset (device_param->speed_ms,  0, SPEED_CACHE * sizeof (double));
18819
18820           device_param->exec_pos = 0;
18821
18822           memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
18823
18824           device_param->outerloop_pos  = 0;
18825           device_param->outerloop_left = 0;
18826           device_param->innerloop_pos  = 0;
18827           device_param->innerloop_left = 0;
18828
18829           // some more resets:
18830
18831           if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
18832
18833           device_param->pws_cnt = 0;
18834
18835           device_param->words_off  = 0;
18836           device_param->words_done = 0;
18837         }
18838
18839         // figure out some workload
18840
18841         if (attack_mode == ATTACK_MODE_STRAIGHT)
18842         {
18843           if (data.wordlist_mode == WL_MODE_FILE)
18844           {
18845             char *dictfile = NULL;
18846
18847             if (induction_dictionaries_cnt)
18848             {
18849               dictfile = induction_dictionaries[0];
18850             }
18851             else
18852             {
18853               dictfile = dictfiles[dictpos];
18854             }
18855
18856             data.dictfile = dictfile;
18857
18858             logfile_sub_string (dictfile);
18859
18860             for (uint i = 0; i < rp_files_cnt; i++)
18861             {
18862               logfile_sub_var_string ("rulefile", rp_files[i]);
18863             }
18864
18865             FILE *fd2 = fopen (dictfile, "rb");
18866
18867             if (fd2 == NULL)
18868             {
18869               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18870
18871               return -1;
18872             }
18873
18874             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18875
18876             fclose (fd2);
18877
18878             if (data.words_cnt == 0)
18879             {
18880               logfile_sub_msg ("STOP");
18881
18882               continue;
18883             }
18884           }
18885         }
18886         else if (attack_mode == ATTACK_MODE_COMBI)
18887         {
18888           char *dictfile  = data.dictfile;
18889           char *dictfile2 = data.dictfile2;
18890
18891           logfile_sub_string (dictfile);
18892           logfile_sub_string (dictfile2);
18893
18894           if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
18895           {
18896             FILE *fd2 = fopen (dictfile, "rb");
18897
18898             if (fd2 == NULL)
18899             {
18900               log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18901
18902               return -1;
18903             }
18904
18905             data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18906
18907             fclose (fd2);
18908           }
18909           else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
18910           {
18911             FILE *fd2 = fopen (dictfile2, "rb");
18912
18913             if (fd2 == NULL)
18914             {
18915               log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
18916
18917               return -1;
18918             }
18919
18920             data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
18921
18922             fclose (fd2);
18923           }
18924
18925           if (data.words_cnt == 0)
18926           {
18927             logfile_sub_msg ("STOP");
18928
18929             continue;
18930           }
18931         }
18932         else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18933         {
18934           char *dictfile = NULL;
18935
18936           if (induction_dictionaries_cnt)
18937           {
18938             dictfile = induction_dictionaries[0];
18939           }
18940           else
18941           {
18942             dictfile = dictfiles[dictpos];
18943           }
18944
18945           data.dictfile = dictfile;
18946
18947           char *mask = data.mask;
18948
18949           logfile_sub_string (dictfile);
18950           logfile_sub_string (mask);
18951
18952           FILE *fd2 = fopen (dictfile, "rb");
18953
18954           if (fd2 == NULL)
18955           {
18956             log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18957
18958             return -1;
18959           }
18960
18961           data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18962
18963           fclose (fd2);
18964
18965           if (data.words_cnt == 0)
18966           {
18967             logfile_sub_msg ("STOP");
18968
18969             continue;
18970           }
18971         }
18972         else if (attack_mode == ATTACK_MODE_BF)
18973         {
18974           local_free (css_buf);
18975           local_free (data.root_css_buf);
18976           local_free (data.markov_css_buf);
18977
18978           char *mask = dictfiles[dictpos];
18979
18980           logfile_sub_string (mask);
18981
18982           // base
18983
18984           css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18985
18986           if (opts_type & OPTS_TYPE_PT_UNICODE)
18987           {
18988             uint css_cnt_unicode = css_cnt * 2;
18989
18990             cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
18991
18992             for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
18993             {
18994               memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
18995
18996               css_buf_unicode[j + 1].cs_buf[0] = 0;
18997               css_buf_unicode[j + 1].cs_len    = 1;
18998             }
18999
19000             free (css_buf);
19001
19002             css_buf = css_buf_unicode;
19003             css_cnt = css_cnt_unicode;
19004           }
19005
19006           // check if mask is not too large or too small for pw_min/pw_max  (*2 if unicode)
19007
19008           uint mask_min = pw_min;
19009           uint mask_max = pw_max;
19010
19011           if (opts_type & OPTS_TYPE_PT_UNICODE)
19012           {
19013             mask_min *= 2;
19014             mask_max *= 2;
19015           }
19016
19017           if ((css_cnt < mask_min) || (css_cnt > mask_max))
19018           {
19019             if (css_cnt < mask_min)
19020             {
19021               log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
19022             }
19023
19024             if (css_cnt > mask_max)
19025             {
19026               log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
19027             }
19028
19029             // skip to next mask
19030
19031             logfile_sub_msg ("STOP");
19032
19033             continue;
19034           }
19035
19036           uint save_css_cnt = css_cnt;
19037
19038           if (opti_type & OPTI_TYPE_SINGLE_HASH)
19039           {
19040             if (opti_type & OPTI_TYPE_APPENDED_SALT)
19041             {
19042               uint  salt_len = (uint)   data.salts_buf[0].salt_len;
19043               char *salt_buf = (char *) data.salts_buf[0].salt_buf;
19044
19045               uint css_cnt_salt = css_cnt + salt_len;
19046
19047               cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
19048
19049               memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
19050
19051               for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
19052               {
19053                 css_buf_salt[j].cs_buf[0] = salt_buf[i];
19054                 css_buf_salt[j].cs_len    = 1;
19055               }
19056
19057               free (css_buf);
19058
19059               css_buf = css_buf_salt;
19060               css_cnt = css_cnt_salt;
19061             }
19062           }
19063
19064           data.mask = mask;
19065           data.css_cnt = css_cnt;
19066           data.css_buf = css_buf;
19067
19068           if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
19069
19070           uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
19071
19072           mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
19073
19074           if (root_table_buf   == NULL) root_table_buf   = (hcstat_table_t *) mycalloc (SP_ROOT_CNT,   sizeof (hcstat_table_t));
19075           if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
19076
19077           sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
19078
19079           markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
19080
19081           cs_t *root_css_buf   = (cs_t *) mycalloc (SP_PW_MAX,           sizeof (cs_t));
19082           cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
19083
19084           data.root_css_buf   = root_css_buf;
19085           data.markov_css_buf = markov_css_buf;
19086
19087           sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
19088
19089           data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
19090
19091           local_free (root_table_buf);
19092           local_free (markov_table_buf);
19093
19094           // copy + args
19095
19096           uint css_cnt_l = css_cnt;
19097           uint css_cnt_r;
19098
19099           if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
19100           {
19101             if (save_css_cnt < 6)
19102             {
19103               css_cnt_r = 1;
19104             }
19105             else if (save_css_cnt == 6)
19106             {
19107               css_cnt_r = 2;
19108             }
19109             else
19110             {
19111               if (opts_type & OPTS_TYPE_PT_UNICODE)
19112               {
19113                 if (save_css_cnt == 8 || save_css_cnt == 10)
19114                 {
19115                   css_cnt_r = 2;
19116                 }
19117                 else
19118                 {
19119                   css_cnt_r = 4;
19120                 }
19121               }
19122               else
19123               {
19124                 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
19125                 {
19126                   css_cnt_r = 3;
19127                 }
19128                 else
19129                 {
19130                   css_cnt_r = 4;
19131                 }
19132               }
19133             }
19134           }
19135           else
19136           {
19137             css_cnt_r = 1;
19138
19139             /* unfinished code?
19140             int sum = css_buf[css_cnt_r - 1].cs_len;
19141
19142             for (uint i = 1; i < 4 && i < css_cnt; i++)
19143             {
19144               if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
19145
19146               css_cnt_r++;
19147
19148               sum *= css_buf[css_cnt_r - 1].cs_len;
19149             }
19150             */
19151           }
19152
19153           css_cnt_l -= css_cnt_r;
19154
19155           data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
19156
19157           for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19158           {
19159             hc_device_param_t *device_param = &data.devices_param[device_id];
19160
19161             if (device_param->skipped) continue;
19162
19163             device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
19164             device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
19165             device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
19166
19167             device_param->kernel_params_mp_l_buf64[3] = 0;
19168             device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
19169             device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
19170             device_param->kernel_params_mp_l_buf32[6] = 0;
19171             device_param->kernel_params_mp_l_buf32[7] = 0;
19172             device_param->kernel_params_mp_l_buf32[8] = 0;
19173
19174             if (opts_type & OPTS_TYPE_PT_ADD01)     device_param->kernel_params_mp_l_buf32[6] = full01;
19175             if (opts_type & OPTS_TYPE_PT_ADD80)     device_param->kernel_params_mp_l_buf32[6] = full80;
19176             if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
19177             if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
19178
19179             device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
19180             device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
19181             device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
19182
19183             device_param->kernel_params_mp_r_buf64[3] = 0;
19184             device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
19185             device_param->kernel_params_mp_r_buf32[5] = 0;
19186             device_param->kernel_params_mp_r_buf32[6] = 0;
19187             device_param->kernel_params_mp_r_buf32[7] = 0;
19188
19189             cl_int CL_err = CL_SUCCESS;
19190
19191             for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp_l[i]);
19192             for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
19193             for (uint i = 4; i < 9; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp_l[i]);
19194
19195             for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem),   (void *) device_param->kernel_params_mp_r[i]);
19196             for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
19197             for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint),  (void *) device_param->kernel_params_mp_r[i]);
19198
19199             if (CL_err != CL_SUCCESS)
19200             {
19201               log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
19202
19203               return -1;
19204             }
19205
19206             CL_err |= 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);
19207             CL_err |= 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);
19208
19209             if (CL_err != CL_SUCCESS)
19210             {
19211               log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
19212
19213               return -1;
19214             }
19215           }
19216         }
19217
19218         u64 words_base = data.words_cnt;
19219
19220         if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19221         {
19222           if (data.kernel_rules_cnt)
19223           {
19224             words_base /= data.kernel_rules_cnt;
19225           }
19226         }
19227         else if (data.attack_kern == ATTACK_KERN_COMBI)
19228         {
19229           if (data.combs_cnt)
19230           {
19231             words_base /= data.combs_cnt;
19232           }
19233         }
19234         else if (data.attack_kern == ATTACK_KERN_BF)
19235         {
19236           if (data.bfs_cnt)
19237           {
19238             words_base /= data.bfs_cnt;
19239           }
19240         }
19241
19242         data.words_base = words_base;
19243
19244         if (keyspace == 1)
19245         {
19246           log_info ("%llu", (unsigned long long int) words_base);
19247
19248           return 0;
19249         }
19250
19251         if (data.words_cur > data.words_base)
19252         {
19253           log_error ("ERROR: Restore value greater keyspace");
19254
19255           return -1;
19256         }
19257
19258         if (data.words_cur)
19259         {
19260           if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19261           {
19262             for (uint i = 0; i < data.salts_cnt; i++)
19263             {
19264               data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
19265             }
19266           }
19267           else if (data.attack_kern == ATTACK_KERN_COMBI)
19268           {
19269             for (uint i = 0; i < data.salts_cnt; i++)
19270             {
19271               data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
19272             }
19273           }
19274           else if (data.attack_kern == ATTACK_KERN_BF)
19275           {
19276             for (uint i = 0; i < data.salts_cnt; i++)
19277             {
19278               data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
19279             }
19280           }
19281         }
19282
19283         /*
19284          * Update loopback file
19285          */
19286
19287         if (loopback == 1)
19288         {
19289           time_t now;
19290
19291           time (&now);
19292
19293           uint random_num = get_random_num (0, 9999);
19294
19295           snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
19296
19297           data.loopback_file = loopback_file;
19298         }
19299
19300         /*
19301          * Update dictionary statistic
19302          */
19303
19304         if (keyspace == 0)
19305         {
19306           dictstat_fp = fopen (dictstat, "wb");
19307
19308           if (dictstat_fp)
19309           {
19310             lock_file (dictstat_fp);
19311
19312             fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
19313
19314             fclose (dictstat_fp);
19315           }
19316         }
19317
19318         /**
19319          * create autotune threads
19320          */
19321
19322         hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
19323
19324         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19325         {
19326           data.devices_status = STATUS_AUTOTUNE;
19327         }
19328
19329         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19330         {
19331           hc_device_param_t *device_param = &devices_param[device_id];
19332
19333           hc_thread_create (c_threads[device_id], thread_autotune, device_param);
19334         }
19335
19336         hc_thread_wait (data.devices_cnt, c_threads);
19337
19338         /*
19339          * Inform user about possible slow speeds
19340          */
19341
19342         uint hardware_power_all = 0;
19343
19344         uint kernel_power_all = 0;
19345
19346         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19347         {
19348           hc_device_param_t *device_param = &devices_param[device_id];
19349
19350           hardware_power_all += device_param->hardware_power;
19351
19352           kernel_power_all += device_param->kernel_power;
19353         }
19354
19355         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
19356
19357         data.kernel_power_all = kernel_power_all;
19358
19359         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19360         {
19361           if (data.words_base < kernel_power_all)
19362           {
19363             if (quiet == 0)
19364             {
19365               clear_prompt ();
19366
19367               log_info ("ATTENTION!");
19368               log_info ("  The wordlist or mask you are using is too small.");
19369               log_info ("  Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
19370               log_info ("  The cracking speed will drop.");
19371               log_info ("  Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
19372               log_info ("");
19373             }
19374           }
19375         }
19376
19377         /**
19378          * create cracker threads
19379          */
19380
19381         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19382         {
19383           data.devices_status = STATUS_RUNNING;
19384         }
19385
19386         if (initial_restore_done == 0)
19387         {
19388           if (data.restore_disable == 0) cycle_restore ();
19389
19390           initial_restore_done = 1;
19391         }
19392
19393         hc_timer_set (&data.timer_running);
19394
19395         if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19396         {
19397           if ((quiet == 0) && (status == 0) && (benchmark == 0))
19398           {
19399             if (quiet == 0) fprintf (stdout, "%s", PROMPT);
19400             if (quiet == 0) fflush (stdout);
19401           }
19402         }
19403         else if (wordlist_mode == WL_MODE_STDIN)
19404         {
19405           if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
19406           if (data.quiet == 0) log_info ("");
19407         }
19408
19409         time_t runtime_start;
19410
19411         time (&runtime_start);
19412
19413         data.runtime_start = runtime_start;
19414
19415         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19416         {
19417           hc_device_param_t *device_param = &devices_param[device_id];
19418
19419           if (wordlist_mode == WL_MODE_STDIN)
19420           {
19421             hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
19422           }
19423           else
19424           {
19425             hc_thread_create (c_threads[device_id], thread_calc, device_param);
19426           }
19427         }
19428
19429         hc_thread_wait (data.devices_cnt, c_threads);
19430
19431         local_free (c_threads);
19432
19433         if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19434         {
19435           data.devices_status = STATUS_EXHAUSTED;
19436         }
19437
19438         logfile_sub_var_uint ("status-after-work", data.devices_status);
19439
19440         data.restore = 0;
19441
19442         if (induction_dictionaries_cnt)
19443         {
19444           unlink (induction_dictionaries[0]);
19445         }
19446
19447         free (induction_dictionaries);
19448
19449         if (attack_mode != ATTACK_MODE_BF)
19450         {
19451           induction_dictionaries = scan_directory (induction_directory);
19452
19453           induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
19454         }
19455
19456         if (benchmark == 1)
19457         {
19458           status_benchmark ();
19459
19460           if (machine_readable == 0)
19461           {
19462             log_info ("");
19463           }
19464         }
19465         else
19466         {
19467           if (quiet == 0)
19468           {
19469             clear_prompt ();
19470
19471             log_info ("");
19472
19473             status_display ();
19474
19475             log_info ("");
19476           }
19477           else
19478           {
19479             if (status == 1)
19480             {
19481               status_display ();
19482             }
19483           }
19484         }
19485
19486         if (induction_dictionaries_cnt)
19487         {
19488           qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
19489
19490           // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
19491
19492           dictpos--;
19493         }
19494
19495         time_t runtime_stop;
19496
19497         time (&runtime_stop);
19498
19499         data.runtime_stop = runtime_stop;
19500
19501         logfile_sub_uint (runtime_start);
19502         logfile_sub_uint (runtime_stop);
19503
19504         logfile_sub_msg ("STOP");
19505
19506         global_free (subid);
19507
19508         // from this point we handle bypass as running
19509
19510         if (data.devices_status == STATUS_BYPASS)
19511         {
19512           data.devices_status = STATUS_RUNNING;
19513         }
19514
19515         // and overwrite benchmark aborts as well
19516
19517         if (data.benchmark == 1)
19518         {
19519           if (data.devices_status == STATUS_ABORTED)
19520           {
19521             data.devices_status = STATUS_RUNNING;
19522           }
19523         }
19524
19525         // finalize task
19526
19527         if (data.devices_status == STATUS_CRACKED) break;
19528         if (data.devices_status == STATUS_ABORTED) break;
19529         if (data.devices_status == STATUS_QUIT)    break;
19530       }
19531
19532       if (data.devices_status == STATUS_CRACKED) break;
19533       if (data.devices_status == STATUS_ABORTED) break;
19534       if (data.devices_status == STATUS_QUIT)    break;
19535     }
19536
19537     // 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
19538     if (attack_mode == ATTACK_MODE_STRAIGHT)
19539     {
19540       if (data.wordlist_mode == WL_MODE_FILE)
19541       {
19542         if (data.dictfile == NULL)
19543         {
19544           if (dictfiles != NULL)
19545           {
19546             data.dictfile = dictfiles[0];
19547
19548             hc_timer_set (&data.timer_running);
19549           }
19550         }
19551       }
19552     }
19553     // NOTE: combi is okay because it is already set beforehand
19554     else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
19555     {
19556       if (data.dictfile == NULL)
19557       {
19558         if (dictfiles != NULL)
19559         {
19560           hc_timer_set (&data.timer_running);
19561
19562           data.dictfile = dictfiles[0];
19563         }
19564       }
19565     }
19566     else if (attack_mode == ATTACK_MODE_BF)
19567     {
19568       if (data.mask == NULL)
19569       {
19570         hc_timer_set (&data.timer_running);
19571
19572         data.mask = masks[0];
19573       }
19574     }
19575
19576     // if cracked / aborted remove last induction dictionary
19577
19578     for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
19579     {
19580       struct stat induct_stat;
19581
19582       if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
19583       {
19584         unlink (induction_dictionaries[file_pos]);
19585       }
19586     }
19587
19588     // wait for inner threads
19589
19590     data.shutdown_inner = 1;
19591
19592     for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
19593     {
19594       hc_thread_wait (1, &inner_threads[thread_idx]);
19595     }
19596
19597     local_free (inner_threads);
19598
19599     // we dont need restore file anymore
19600     if (data.restore_disable == 0)
19601     {
19602       if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
19603       {
19604         unlink (eff_restore_file);
19605         unlink (new_restore_file);
19606       }
19607       else
19608       {
19609         cycle_restore ();
19610       }
19611     }
19612
19613     // finally save left hashes
19614
19615     if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
19616     {
19617       save_hash ();
19618     }
19619
19620     /**
19621      * Clean up
19622      */
19623
19624     for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19625     {
19626       hc_device_param_t *device_param = &data.devices_param[device_id];
19627
19628       if (device_param->skipped) continue;
19629
19630       cl_int CL_err = CL_SUCCESS;
19631
19632       local_free (device_param->combs_buf);
19633       local_free (device_param->hooks_buf);
19634       local_free (device_param->device_name);
19635       local_free (device_param->device_name_chksum);
19636       local_free (device_param->device_version);
19637       local_free (device_param->driver_version);
19638
19639       if (device_param->pws_buf)            myfree (device_param->pws_buf);
19640
19641       if (device_param->d_pws_buf)          CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
19642       if (device_param->d_pws_amp_buf)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
19643       if (device_param->d_rules)            CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules);
19644       if (device_param->d_rules_c)          CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
19645       if (device_param->d_combs)            CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs);
19646       if (device_param->d_combs_c)          CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
19647       if (device_param->d_bfs)              CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
19648       if (device_param->d_bfs_c)            CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
19649       if (device_param->d_bitmap_s1_a)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
19650       if (device_param->d_bitmap_s1_b)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
19651       if (device_param->d_bitmap_s1_c)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
19652       if (device_param->d_bitmap_s1_d)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
19653       if (device_param->d_bitmap_s2_a)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
19654       if (device_param->d_bitmap_s2_b)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
19655       if (device_param->d_bitmap_s2_c)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
19656       if (device_param->d_bitmap_s2_d)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
19657       if (device_param->d_plain_bufs)       CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
19658       if (device_param->d_digests_buf)      CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
19659       if (device_param->d_digests_shown)    CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
19660       if (device_param->d_salt_bufs)        CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
19661       if (device_param->d_esalt_bufs)       CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
19662       if (device_param->d_tmps)             CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
19663       if (device_param->d_hooks)            CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
19664       if (device_param->d_result)           CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_result);
19665       if (device_param->d_scryptV0_buf)     CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
19666       if (device_param->d_scryptV1_buf)     CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
19667       if (device_param->d_scryptV2_buf)     CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
19668       if (device_param->d_scryptV3_buf)     CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
19669       if (device_param->d_root_css_buf)     CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
19670       if (device_param->d_markov_css_buf)   CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
19671       if (device_param->d_tm_c)             CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
19672
19673       if (CL_err != CL_SUCCESS)
19674       {
19675         log_error ("ERROR: clReleaseMemObject(): %s\n", val2cstr_cl (CL_err));
19676
19677         return -1;
19678       }
19679
19680       if (device_param->kernel1)        CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel1);
19681       if (device_param->kernel12)       CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel12);
19682       if (device_param->kernel2)        CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel2);
19683       if (device_param->kernel23)       CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel23);
19684       if (device_param->kernel3)        CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel3);
19685       if (device_param->kernel_mp)      CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
19686       if (device_param->kernel_mp_l)    CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
19687       if (device_param->kernel_mp_r)    CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
19688       if (device_param->kernel_tm)      CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
19689       if (device_param->kernel_amp)     CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
19690       if (device_param->kernel_memset)  CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
19691
19692       if (CL_err != CL_SUCCESS)
19693       {
19694         log_error ("ERROR: clReleaseKernel(): %s\n", val2cstr_cl (CL_err));
19695
19696         return -1;
19697       }
19698
19699       if (device_param->program)     CL_err |= hc_clReleaseProgram (data.ocl, device_param->program);
19700       if (device_param->program_mp)  CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_mp);
19701       if (device_param->program_amp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_amp);
19702
19703       if (CL_err != CL_SUCCESS)
19704       {
19705         log_error ("ERROR: clReleaseProgram(): %s\n", val2cstr_cl (CL_err));
19706
19707         return -1;
19708       }
19709
19710       if (device_param->command_queue) CL_err |= hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
19711
19712       if (CL_err != CL_SUCCESS)
19713       {
19714         log_error ("ERROR: clReleaseCommandQueue(): %s\n", val2cstr_cl (CL_err));
19715
19716         return -1;
19717       }
19718
19719       if (device_param->context) CL_err |= hc_clReleaseContext (data.ocl, device_param->context);
19720
19721       if (CL_err != CL_SUCCESS)
19722       {
19723         log_error ("ERROR: hc_clReleaseContext(): %s\n", val2cstr_cl (CL_err));
19724
19725         return -1;
19726       }
19727     }
19728
19729     // reset default fan speed
19730
19731     #ifdef HAVE_HWMON
19732     if (gpu_temp_disable == 0)
19733     {
19734       if (gpu_temp_retain != 0)
19735       {
19736         hc_thread_mutex_lock (mux_adl);
19737
19738         for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19739         {
19740           hc_device_param_t *device_param = &data.devices_param[device_id];
19741
19742           if (device_param->skipped) continue;
19743
19744           if (data.hm_device[device_id].fan_set_supported == 1)
19745           {
19746             int rc = -1;
19747
19748             if (device_param->device_vendor_id == VENDOR_ID_AMD)
19749             {
19750               rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
19751             }
19752             else if (device_param->device_vendor_id == VENDOR_ID_NV)
19753             {
19754               #ifdef __linux__
19755               rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
19756               #endif
19757
19758               #ifdef WIN
19759               rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
19760               #endif
19761             }
19762
19763             if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
19764           }
19765         }
19766
19767         hc_thread_mutex_unlock (mux_adl);
19768       }
19769     }
19770
19771     // reset power tuning
19772
19773     if (powertune_enable == 1)
19774     {
19775       hc_thread_mutex_lock (mux_adl);
19776
19777       for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19778       {
19779         hc_device_param_t *device_param = &data.devices_param[device_id];
19780
19781         if (device_param->skipped) continue;
19782
19783         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
19784         {
19785           if (data.hm_device[device_id].od_version == 6)
19786           {
19787             // check powertune capabilities first, if not available then skip device
19788
19789             int powertune_supported = 0;
19790
19791             if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
19792             {
19793               log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
19794
19795               return -1;
19796             }
19797
19798             if (powertune_supported != 0)
19799             {
19800               // powercontrol settings
19801
19802               if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
19803               {
19804                 log_info ("ERROR: Failed to restore the ADL PowerControl values");
19805
19806                 return -1;
19807               }
19808
19809               // clocks
19810
19811               ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
19812
19813               performance_state->iNumberOfPerformanceLevels = 2;
19814
19815               performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
19816               performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
19817               performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
19818               performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
19819
19820               if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
19821               {
19822                 log_info ("ERROR: Failed to restore ADL performance state");
19823
19824                 return -1;
19825               }
19826
19827               local_free (performance_state);
19828             }
19829           }
19830         }
19831
19832         if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
19833         {
19834           unsigned int limit = nvml_power_limit[device_id];
19835
19836           if (limit > 0)
19837           {
19838             hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
19839           }
19840         }
19841       }
19842
19843       hc_thread_mutex_unlock (mux_adl);
19844     }
19845
19846     if (gpu_temp_disable == 0)
19847     {
19848       if (data.hm_nvml)
19849       {
19850         hm_NVML_nvmlShutdown (data.hm_nvml);
19851
19852         nvml_close (data.hm_nvml);
19853
19854         data.hm_nvml = NULL;
19855       }
19856
19857       if (data.hm_nvapi)
19858       {
19859         hm_NvAPI_Unload (data.hm_nvapi);
19860
19861         nvapi_close (data.hm_nvapi);
19862
19863         data.hm_nvapi = NULL;
19864       }
19865
19866       if (data.hm_xnvctrl)
19867       {
19868         hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
19869
19870         xnvctrl_close (data.hm_xnvctrl);
19871
19872         data.hm_xnvctrl = NULL;
19873       }
19874
19875       if (data.hm_adl)
19876       {
19877         hm_ADL_Main_Control_Destroy (data.hm_adl);
19878
19879         adl_close (data.hm_adl);
19880
19881         data.hm_adl = NULL;
19882       }
19883     }
19884     #endif // HAVE_HWMON
19885
19886     // free memory
19887
19888     local_free (masks);
19889
19890     local_free (dictstat_base);
19891
19892     for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
19893     {
19894       pot_t *pot_ptr = &pot[pot_pos];
19895
19896       hash_t *hash = &pot_ptr->hash;
19897
19898       local_free (hash->digest);
19899
19900       if (isSalted)
19901       {
19902         local_free (hash->salt);
19903       }
19904     }
19905
19906     local_free (pot);
19907
19908     local_free (all_kernel_rules_cnt);
19909     local_free (all_kernel_rules_buf);
19910
19911     local_free (wl_data->buf);
19912     local_free (wl_data);
19913
19914     local_free (bitmap_s1_a);
19915     local_free (bitmap_s1_b);
19916     local_free (bitmap_s1_c);
19917     local_free (bitmap_s1_d);
19918     local_free (bitmap_s2_a);
19919     local_free (bitmap_s2_b);
19920     local_free (bitmap_s2_c);
19921     local_free (bitmap_s2_d);
19922
19923     #ifdef HAVE_HWMON
19924     local_free (od_clock_mem_status);
19925     local_free (od_power_control_status);
19926     local_free (nvml_power_limit);
19927     #endif
19928
19929     global_free (devices_param);
19930
19931     global_free (kernel_rules_buf);
19932
19933     global_free (root_css_buf);
19934     global_free (markov_css_buf);
19935
19936     global_free (digests_buf);
19937     global_free (digests_shown);
19938     global_free (digests_shown_tmp);
19939
19940     global_free (salts_buf);
19941     global_free (salts_shown);
19942
19943     global_free (esalts_buf);
19944
19945     global_free (words_progress_done);
19946     global_free (words_progress_rejected);
19947     global_free (words_progress_restored);
19948
19949     if (pot_fp) fclose (pot_fp);
19950
19951     if (data.devices_status == STATUS_QUIT) break;
19952   }
19953
19954   // wait for outer threads
19955
19956   data.shutdown_outer = 1;
19957
19958   for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
19959   {
19960     hc_thread_wait (1, &outer_threads[thread_idx]);
19961   }
19962
19963   local_free (outer_threads);
19964
19965   // destroy others mutex
19966
19967   hc_thread_mutex_delete (mux_dispatcher);
19968   hc_thread_mutex_delete (mux_counter);
19969   hc_thread_mutex_delete (mux_display);
19970   hc_thread_mutex_delete (mux_adl);
19971
19972   // free memory
19973
19974   local_free (eff_restore_file);
19975   local_free (new_restore_file);
19976
19977   local_free (rd);
19978
19979   // tuning db
19980
19981   tuning_db_destroy (tuning_db);
19982
19983   // loopback
19984
19985   local_free (loopback_file);
19986
19987   if (loopback == 1) unlink (loopback_file);
19988
19989   // induction directory
19990
19991   if (induction_dir == NULL)
19992   {
19993     if (attack_mode != ATTACK_MODE_BF)
19994     {
19995       if (rmdir (induction_directory) == -1)
19996       {
19997         if (errno == ENOENT)
19998         {
19999           // good, we can ignore
20000         }
20001         else if (errno == ENOTEMPTY)
20002         {
20003           // good, we can ignore
20004         }
20005         else
20006         {
20007           log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
20008
20009           return -1;
20010         }
20011       }
20012
20013       local_free (induction_directory);
20014     }
20015   }
20016
20017   // outfile-check directory
20018
20019   if (outfile_check_dir == NULL)
20020   {
20021     if (rmdir (outfile_check_directory) == -1)
20022     {
20023       if (errno == ENOENT)
20024       {
20025         // good, we can ignore
20026       }
20027       else if (errno == ENOTEMPTY)
20028       {
20029         // good, we can ignore
20030       }
20031       else
20032       {
20033         log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
20034
20035         return -1;
20036       }
20037     }
20038
20039     local_free (outfile_check_directory);
20040   }
20041
20042   time_t proc_stop;
20043
20044   time (&proc_stop);
20045
20046   logfile_top_uint (proc_start);
20047   logfile_top_uint (proc_stop);
20048
20049   logfile_top_msg ("STOP");
20050
20051   if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
20052   if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
20053
20054   if (data.ocl) ocl_close (data.ocl);
20055
20056   if (data.devices_status == STATUS_ABORTED)            return 2;
20057   if (data.devices_status == STATUS_QUIT)               return 2;
20058   if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
20059   if (data.devices_status == STATUS_EXHAUSTED)          return 1;
20060   if (data.devices_status == STATUS_CRACKED)            return 0;
20061
20062   return -1;
20063 }