Merge branch 'master' of https://github.com/hashcat/hashcat

OpenCL/inc_ecc_secp256k1.cl

@@ -512,6 +512,9 @@ DECLSPEC void mod_512 (u32 *n)
 
     // substract (a -= r):
 
+    if ((r[ 0] | r[ 1] | r[ 2] | r[ 3] | r[ 4] | r[ 5] | r[ 6] | r[ 7] |
+         r[ 8] | r[ 9] | r[10] | r[11] | r[12] | r[13] | r[14] | r[15]) == 0) break;
+
     r[ 0] = a[ 0] - r[ 0];
     r[ 1] = a[ 1] - r[ 1];
     r[ 2] = a[ 2] - r[ 2];

OpenCL/inc_vendor.h

@@ -99,6 +99,11 @@
 #define REAL_SHM
 #endif
 
+// So far, only used by -m 22100 and only affects NVIDIA on OpenCL. CUDA seems to work fine.
+#ifdef FORCE_DISABLE_SHM
+#undef REAL_SHM
+#endif
+
 #ifdef REAL_SHM
 #define SHM_TYPE LOCAL_AS
 #else

docs/hashcat-plugin-development-guide.md

@@ -394,7 +394,7 @@ This configuration item is a bitmask field. There are a few switches which you c
 The decoder function is the function that is called again and again for every line in your hashfile. We also call this sometimes the hash parser. Here you have to program the logic which decodes the line into its components and then stores them in the standardized data structure which hashcat understands.
 
 Typically hash files are text files in which each hash is stored in a single line. Before the decoder function is called, Hashcat opens the hash file and scans the number of lines. Based on this information, it pre-allocates memory buffers for the hash digest, the salt and the esalt so you do not need to allocate any buffers from inside the decoder. If you allocate buffers from inside the decoder, you must free them as well. The size of the digest is based on what is returned from module_dgst_size(). The salt_t is a fixed size structure and the esalt size is known from module_esalt_size(). There is also some more rarely used buffers like module_hook_salt_size() but the logic is always the same. Hashcat simply multiplies the size of all these different structures by the number of lines. It then rewinds the file handle and starts iterating. For each iteration of these input lines, the module_hash_decode() function is called. The input pointer points to the new hash line and the output pointers point to the corresponding previously allocated buffers. You can directly access the pointers to store the digest, salt, esalt and other buffers without any offsets.
- 
+
 In hashcat there are two different types of salt structures. It is essential to understand them; please read the section "About salts" at the end of this document first. If you are unaware about the different concepts of salt_t and esalt, you really need to read that section before you continue this section.
 
 For instance, if your crypto algorithm is something like MD5(MD5($pass.$salt)), then you can expect to find both a hash and a salt in each of your hash lines. In the decoder function, it is up to you to split these two parts (typically by using the tokenizer - please read the tokenizer section below) and copy them into a standardized hashcat structure.
@@ -508,7 +508,7 @@ This is the password to crack the hash given in module_st_hash() for the self-te
 
 This is the second necessary ingredient for creating a plugin. Particular attention should be paid to the development of the kernel. Compiling the kernel takes a relatively long time, so both hashcat and the various compute APIs try to save a binary kernel in a cached structure. This serves to reduce the startup time and it is important for the user experience (UX). This however can be a pain as a developer.
 
-NOTE: You -must- manually delete all cached kernels with every change to your kernel code. This is -very- important! 
+NOTE: You -must- manually delete all cached kernels with every change to your kernel code. This is -very- important!
 
 ```
 $ rm -rf kernels/

src/modules/module_00040.c

@@ -29,7 +29,7 @@ static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_PT_ADD80
                                   | OPTS_TYPE_PT_ADDBITS14
                                   | OPTS_TYPE_PT_UTF16LE;
-static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const u32   SALT_TYPE      = SALT_TYPE_GENERIC;
 static const char *ST_PASS        = "hashcat";
 static const char *ST_HASH        = "23a8a90599fc5d0d15265d4d3b565f6e:58802707";
 

src/modules/module_04710.c

@@ -27,7 +27,7 @@ static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
 static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_PT_ADD80
                                   | OPTS_TYPE_PT_ADDBITS14;
-static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const u32   SALT_TYPE      = SALT_TYPE_GENERIC;
 static const char *ST_PASS        = "hashcat";
 static const char *ST_HASH        = "53c724b7f34f09787ed3f1b316215fc35c789504:hashcat1";
 

src/modules/module_20710.c

@@ -28,7 +28,7 @@ static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
 static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_BE
                                   | OPTS_TYPE_PT_ADD80
                                   | OPTS_TYPE_PT_ADDBITS15;
-static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const u32   SALT_TYPE      = SALT_TYPE_GENERIC;
 static const char *ST_PASS        = "hashcat";
 static const char *ST_HASH        = "bfede293ecf6539211a7305ea218b9f3f608953130405cda9eaba6fb6250f824:7218532375810603";
 

src/modules/module_21200.c

@@ -27,7 +27,7 @@ static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
 static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_PT_ADD80
                                   | OPTS_TYPE_PT_ADDBITS14;
-static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const u32   SALT_TYPE      = SALT_TYPE_GENERIC;
 static const char *ST_PASS        = "hashcat";
 static const char *ST_HASH        = "e69b7a7fe1bf2ad9ef116f79551ee919:baa038987e582431a6d";
 
@@ -60,8 +60,8 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
   token.attr[0]    = TOKEN_ATTR_VERIFY_LENGTH
                    | TOKEN_ATTR_VERIFY_HEX;
 
-  token.len_min[1] = 19;
-  token.len_max[1] = 19;
+  token.len_min[1] = SALT_MIN;
+  token.len_max[1] = SALT_MAX;
   token.attr[1]    = TOKEN_ATTR_VERIFY_LENGTH;
 
   if (hashconfig->opts_type & OPTS_TYPE_ST_HEX)

src/modules/module_21300.c

@@ -27,7 +27,7 @@ static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
 static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_PT_ADD80
                                   | OPTS_TYPE_PT_ADDBITS14;
-static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const u32   SALT_TYPE      = SALT_TYPE_GENERIC;
 static const char *ST_PASS        = "hashcat";
 static const char *ST_HASH        = "799dc7d9aa4d3f404cc21a4936dbdcde:68617368636174"; //6d455b6e8945bebfd0a5878eaa201523:hashcat"; //c8f4f1202e7aaebb14e49903ca973d39:943038186";
 

src/modules/module_22100.c

@@ -77,7 +77,7 @@ char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAY
   // NVIDIA GPU
   if (device_param->opencl_device_vendor_id == VENDOR_ID_NV)
   {
-    hc_asprintf (&jit_build_options, "-D _unroll");
+    hc_asprintf (&jit_build_options, "-D _unroll -D FORCE_DISABLE_SHM");
   }
 
   // AMD-GPU-PRO

tools/test_modules/m21200.pm

@@ -11,12 +11,12 @@ use warnings;
 use Digest::MD5 qw (md5_hex);
 use Digest::SHA qw (sha1_hex);
 
-sub module_constraints { [[0, 256], [19, 19], [0, 55], [-1, -1], [-1, -1]] }
+sub module_constraints { [[0, 256], [0, 256], [0, 55], [-1, -1], [-1, -1]] }
 
 sub module_generate_hash
 {
   my $word = shift;
-  my $salt = random_hex_string (19, 19);
+  my $salt = shift;
 
   my $digest = md5_hex (sha1_hex ($salt) . md5_hex ($word));
 

tools/test_modules/m21300.pm

@@ -11,18 +11,13 @@ use warnings;
 use Digest::MD5 qw (md5_hex);
 use Digest::SHA qw (sha1_hex);
 
-sub module_constraints { [[0, 256], [1, 256], [0, 55], [-1, -1], [-1, -1]] }
+sub module_constraints { [[0, 256], [0, 256], [0, 55], [0, 55], [0, 55]] }
 
 sub module_generate_hash
 {
   my $word = shift;
   my $salt = shift;
 
-  if (length $salt == 0)
-  {
-    $salt = random_hex_string (1, 256);
-  }
-
   my $digest = md5_hex ($salt . sha1_hex ($salt . $word));
 
   my $hash = sprintf ("%s:%s", $digest, $salt);