The goal of this branch to develop a plugin like interface for hashcat kernels.

The modification of existing core source files to add new hashcat kernels conflicts with the idea of having private hashcat kernel repositories especially when backporting latest hashcat core changes and new features.
The final outcome of this should be a plugin format that does not require modifications on the core soruce files.
Also convert all existing hash-modes to hashcat modules.
We'll start with dynamic loading the modules at runtime rather than linking them at compile time.
This will require some extra code for different OS types but should beneficial on a long term.
This commit add some first ideas of how such modules could look like, however there's no dynamic loading interface yet.
Next steps will be removing all hash-mode depending special code from source files and move them to the modules.
Finally merge with master.

include/interface.h

@@ -1664,16 +1664,19 @@ void to_hccapx_t (hashcat_ctx_t *hashcat_ctx, hccapx_t *hccapx, const u32 salt_p
 
 int ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const size_t out_len, const u32 salt_pos, const u32 digest_pos);
 
+int input_tokenizer (const u8 *input_buf, const int input_len, token_t *token);
+bool initialize_keyboard_layout_mapping (hashcat_ctx_t *hashcat_ctx, const char *filename, keyboard_layout_mapping_t *keyboard_layout_mapping, int *keyboard_layout_mapping_cnt);
+
 int         hashconfig_init                   (hashcat_ctx_t *hashcat_ctx);
 void        hashconfig_destroy                (hashcat_ctx_t *hashcat_ctx);
 u32         hashconfig_forced_kernel_threads  (hashcat_ctx_t *hashcat_ctx);
 u32         hashconfig_get_kernel_threads     (hashcat_ctx_t *hashcat_ctx, const hc_device_param_t *device_param);
 u32         hashconfig_get_kernel_loops       (hashcat_ctx_t *hashcat_ctx);
 int         hashconfig_general_defaults       (hashcat_ctx_t *hashcat_ctx);
-int         hashconfig_get_pw_min             (hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
-int         hashconfig_get_pw_max             (hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
-int         hashconfig_get_salt_min           (hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
-int         hashconfig_get_salt_max           (hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
+int         hashconfig_pw_min                 (const hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
+int         hashconfig_pw_max                 (const hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
+int         hashconfig_salt_min               (const hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
+int         hashconfig_salt_max               (const hashcat_ctx_t *hashcat_ctx, const bool optimized_kernel);
 void        hashconfig_benchmark_defaults     (hashcat_ctx_t *hashcat_ctx, salt_t *salt, void *esalt, void *hook_salt);
 const char *hashconfig_benchmark_mask         (hashcat_ctx_t *hashcat_ctx);
 

include/modules.h

@@ -0,0 +1,48 @@
+
+#ifndef _MODULES_H
+#define _MODULES_H
+
+typedef struct hashcat_module
+{
+  const char *(*module_hash_name)    ();
+  u32         (*module_salt_type)    ();
+  u32         (*module_attack_exec)  ();
+  u64         (*module_opts_type)    ();
+  u32         (*module_dgst_size)    ();
+  u32         (*module_opti_type)    ();
+  u32         (*module_dgst_pos0)    ();
+  u32         (*module_dgst_pos1)    ();
+  u32         (*module_dgst_pos2)    ();
+  u32         (*module_dgst_pos3)    ();
+  const char *(*module_st_hash)      ();
+  const char *(*module_st_pass)      ();
+  u32         (*module_pw_min)       (const hashcat_ctx_t *);
+  u32         (*module_pw_max)       (const hashcat_ctx_t *);
+  u32         (*module_salt_min)     (const hashcat_ctx_t *);
+  u32         (*module_salt_max)     (const hashcat_ctx_t *);
+  int         (*module_hash_decode)  (const hashcat_ctx_t *, const u8 *, const int, hash_t *);
+  int         (*module_hash_encode)  (const hashcat_ctx_t *, const void *, const salt_t *, const void *, u8 *, const size_t);
+
+} hashcat_module_t;
+
+const char *module_hash_name    ();
+u32         module_salt_type    ();
+u32         module_attack_exec  ();
+u64         module_opts_type    ();
+u32         module_dgst_size    ();
+u32         module_opti_type    ();
+u32         module_dgst_pos0    ();
+u32         module_dgst_pos1    ();
+u32         module_dgst_pos2    ();
+u32         module_dgst_pos3    ();
+const char *module_st_hash      ();
+const char *module_st_pass      ();
+u32         module_pw_min       (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx);
+u32         module_pw_max       (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx);
+u32         module_salt_min     (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx);
+u32         module_salt_max     (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx);
+int         module_hash_decode  (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx, const u8 *input_buf, const int input_len, hash_t *hash_buf);
+int         module_hash_encode  (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *digest, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt, u8 *output_buf, const size_t output_size);
+void        module_register     (hashcat_module_t *hashcat_module);
+
+#endif // _MODULES_H

include/shared.h

@@ -75,7 +75,7 @@ u32 power_of_two_floor_32 (const u32 v);
 u32 round_up_multiple_32 (const u32 v, const u32 m);
 u64 round_up_multiple_64 (const u64 v, const u64 m);
 
-void hc_strncat (u8 *dst, u8 *src, const size_t n);
+void hc_strncat (u8 *dst, const u8 *src, const size_t n);
 
 int count_char (const u8 *buf, const int len, const u8 c);
 float get_entropy (const u8 *buf, const int len);

include/types.h

@@ -2248,7 +2248,7 @@ typedef struct token
 
   int sep[MAX_TOKENS];
 
-  u8 *buf[MAX_TOKENS];
+  const u8 *buf[MAX_TOKENS];
   int len[MAX_TOKENS];
 
   int len_min[MAX_TOKENS];
@@ -2256,7 +2256,7 @@ typedef struct token
 
   int attr[MAX_TOKENS];
 
-  u8 *opt_buf;
+  const u8 *opt_buf;
   int opt_len;
 
 } token_t;