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.
pull/1832/head
Jens Steube 6 years ago
parent 09ec2a9c3c
commit 55add7c60e

@ -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);

@ -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

@ -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);

@ -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;

@ -0,0 +1,176 @@
/**
* Author......: See docs/credits.txt
* License.....: MIT
*/
#include "common.h"
#include "types.h"
#include "modules.h"
#include "convert.h"
#include "interface.h"
#include "inc_hash_constants.h"
static const char *HASH_NAME = "NTLM";
static const u32 SALT_TYPE = SALT_TYPE_NONE;
static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL;
static const u32 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE
| OPTS_TYPE_PT_ADD80
| OPTS_TYPE_PT_ADDBITS14
| OPTS_TYPE_PT_UTF16LE;
static const u32 DGST_SIZE = DGST_SIZE_4_4;
static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE
| OPTI_TYPE_PRECOMPUTE_INIT
| OPTI_TYPE_PRECOMPUTE_MERKLE
| OPTI_TYPE_MEET_IN_MIDDLE
| OPTI_TYPE_EARLY_SKIP
| OPTI_TYPE_NOT_ITERATED
| OPTI_TYPE_NOT_SALTED
| OPTI_TYPE_RAW_HASH;
static const u32 DGST_POS0 = 0;
static const u32 DGST_POS1 = 3;
static const u32 DGST_POS2 = 2;
static const u32 DGST_POS3 = 1;
static const char *ST_HASH = "b4b9b02e6f09a9bd760f388b67351e2b";
static const char *ST_PASS = "hashcat";
static const char *SIGNATURE = NULL;
const char *module_hash_name () { return HASH_NAME; }
u32 module_salt_type () { return SALT_TYPE; }
u32 module_attack_exec () { return ATTACK_EXEC; }
u64 module_opts_type () { return OPTS_TYPE; }
u32 module_dgst_size () { return DGST_SIZE; }
u32 module_opti_type () { return OPTI_TYPE; }
u32 module_dgst_pos0 () { return DGST_POS0; }
u32 module_dgst_pos1 () { return DGST_POS1; }
u32 module_dgst_pos2 () { return DGST_POS2; }
u32 module_dgst_pos3 () { return DGST_POS3; }
const char *module_st_hash () { return ST_HASH; }
const char *module_st_pass () { return ST_PASS; }
u32 module_salt_min (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL);
return hashconfig_salt_min (hashcat_ctx, optimized_kernel);
}
u32 module_salt_max (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL);
return hashconfig_salt_max (hashcat_ctx, optimized_kernel);
}
u32 module_pw_min (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL);
return hashconfig_pw_min (hashcat_ctx, optimized_kernel);
}
u32 module_pw_max (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL);
return hashconfig_pw_max (hashcat_ctx, optimized_kernel);
}
int module_hash_decode (MAYBE_UNUSED const hashcat_ctx_t *hashcat_ctx, const u8 *input_buf, const int input_len, hash_t *hash_buf)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
u32 *digest = (u32 *) hash_buf->digest;
token_t token;
token.token_cnt = 1;
token.len_min[0] = 32;
token.len_max[0] = 32;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
const u8 *hash_pos = token.buf[0];
digest[0] = hex_to_u32 (hash_pos + 0);
digest[1] = hex_to_u32 (hash_pos + 8);
digest[2] = hex_to_u32 (hash_pos + 16);
digest[3] = hex_to_u32 (hash_pos + 24);
if (hashconfig->opti_type & OPTI_TYPE_PRECOMPUTE_MERKLE)
{
digest[0] -= MD4M_A;
digest[1] -= MD4M_B;
digest[2] -= MD4M_C;
digest[3] -= MD4M_D;
}
return (PARSER_OK);
}
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)
{
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
u32 *digest_u32 = (u32 *) digest;
// we can not change anything in the original buffer, otherwise destroying sorting
// therefore create some local buffer
u32 digest_buf[4];
digest_buf[0] = digest_u32[0];
digest_buf[1] = digest_u32[1];
digest_buf[2] = digest_u32[2];
digest_buf[3] = digest_u32[3];
if (hashconfig->opti_type & OPTI_TYPE_PRECOMPUTE_MERKLE)
{
digest_buf[0] += MD4M_A;
digest_buf[1] += MD4M_B;
digest_buf[2] += MD4M_C;
digest_buf[3] += MD4M_D;
}
const int output_len = snprintf ((char *) output_buf, output_size - 1, "%08x%08x%08x%08x",
digest_buf[0],
digest_buf[1],
digest_buf[2],
digest_buf[3]);
return output_len;
}
void module_register (hashcat_module_t *hashcat_module)
{
hashcat_module->module_hash_name = module_hash_name;
hashcat_module->module_salt_type = module_salt_type;
hashcat_module->module_attack_exec = module_attack_exec;
hashcat_module->module_opts_type = module_opts_type;
hashcat_module->module_dgst_size = module_dgst_size;
hashcat_module->module_opti_type = module_opti_type;
hashcat_module->module_dgst_pos0 = module_dgst_pos0;
hashcat_module->module_dgst_pos1 = module_dgst_pos1;
hashcat_module->module_dgst_pos2 = module_dgst_pos2;
hashcat_module->module_dgst_pos3 = module_dgst_pos3;
hashcat_module->module_st_hash = module_st_hash;
hashcat_module->module_st_pass = module_st_pass;
hashcat_module->module_salt_min = module_salt_min;
hashcat_module->module_salt_max = module_salt_max;
hashcat_module->module_pw_min = module_pw_min;
hashcat_module->module_pw_max = module_pw_max;
hashcat_module->module_hash_decode = module_hash_decode;
hashcat_module->module_hash_encode = module_hash_encode;
}

@ -530,6 +530,13 @@ $(HASHCAT_FRONTEND): src/main.c $(NATIVE_STATIC_OBJS)
$(CC) $(CFLAGS_NATIVE) $^ -o $@ $(LFLAGS_NATIVE) -DCOMPTIME=$(COMPTIME) -DVERSION_TAG=\"$(VERSION_TAG)\" -DINSTALL_FOLDER=\"$(INSTALL_FOLDER)\" -DSHARED_FOLDER=\"$(SHARED_FOLDER)\" -DDOCUMENT_FOLDER=\"$(DOCUMENT_FOLDER)\"
endif
##
## native compiled modules
##
modules/m%.so: modules/m%.c
$(CC) -c $(CFLAGS_NATIVE) $< -o $@ -shared
##
## cross compiled hashcat
##

File diff suppressed because it is too large Load Diff

@ -356,7 +356,7 @@ int build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
}
}
const u32 pw_max = hashconfig_get_pw_max (hashcat_ctx, false);
const u32 pw_max = hashconfig_pw_max (hashcat_ctx, false);
if (plain_len > (int) hashconfig->pw_max) plain_len = MIN (plain_len, (int) pw_max);

@ -668,11 +668,12 @@ u64 round_up_multiple_64 (const u64 v, const u64 m)
// difference to original strncat is no returncode and u8* instead of char*
void hc_strncat (u8 *dst, u8 *src, const size_t n)
void hc_strncat (u8 *dst, const u8 *src, const size_t n)
{
const size_t dst_len = strlen ((char *) dst);
u8 *src_ptr = src;
const u8 *src_ptr = src;
u8 *dst_ptr = dst + dst_len;
for (size_t i = 0; i < n && *src_ptr != 0; i++)

Loading…
Cancel
Save