arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2024-11-22 16:18:09 +00:00
Code Issues Releases Wiki Activity

Show advice to use optimized kernels only if there's actually one for this hash-mode

Browse Source
This commit is contained in:
jsteube 2017-09-16 22:33:04 +02:00
parent 34c5eac550
commit 5551337cf6
6 changed files with 103 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/types.h
View File

@ -839,7 +839,10 @@ struct hashconfig
u32 dgst_pos2;
u32 dgst_pos3;
u32 is_salted;
bool is_salted;
bool has_pure_kernel;
bool has_optimized_kernel;
// sizes have to be size_t

58
src/hashes.c
View File

@ -85,7 +85,7 @@ int sort_by_hash (const void *v1, const void *v2, void *v3)
hashconfig_t *hashconfig = (hashconfig_t *) v3;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
const salt_t *s1 = h1->salt;
const salt_t *s2 = h2->salt;
@ -609,16 +609,16 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
}
}
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
salts_buf = (salt_t *) hccalloc (hashes_avail, sizeof (salt_t));
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
esalts_buf = (void *) hccalloc (hashes_avail, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
hook_salts_buf = (seven_zip_hook_salt_t *) hccalloc (hashes_avail, hashconfig->hook_salt_size);
}
@ -632,16 +632,16 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{
hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * hashconfig->dgst_size);
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
hashes_buf[hash_pos].hook_salt = ((char *) hook_salts_buf) + (hash_pos * hashconfig->hook_salt_size);
}
@ -719,17 +719,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
memset (hashes_buf[0].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[0].esalt, 0, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[0].hook_salt, 0, hashconfig->hook_salt_size);
}
@ -766,12 +766,12 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
break;
}
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[hashes_cnt].esalt, 0, hashconfig->esalt_size);
@ -789,7 +789,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
}
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[hashes_cnt].hook_salt, 0, hashconfig->hook_salt_size);
}
@ -997,17 +997,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[hashes_cnt].esalt, 0, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[hashes_cnt].hook_salt, 0, hashconfig->hook_salt_size);
}
@ -1108,7 +1108,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{
EVENT (EVENT_HASHLIST_SORT_HASH_PRE);
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig);
}
@ -1174,7 +1174,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
{
// do not sort, because we need to keep all hashes in this particular case
}
else if (hashconfig->is_salted)
else if (hashconfig->is_salted == true)
{
if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
{
@ -1215,7 +1215,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
void *esalts_buf_new = NULL;
void *hook_salts_buf_new = NULL;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
salts_buf_new = (salt_t *) hccalloc (hashes_cnt, sizeof (salt_t));
}
@ -1224,12 +1224,12 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
salts_buf_new = (salt_t *) hccalloc (1, sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
esalts_buf_new = (void *) hccalloc (hashes_cnt, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
hook_salts_buf_new = (void *) hccalloc (hashes_cnt, hashconfig->hook_salt_size);
}
@ -1265,7 +1265,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
hashes_buf[0].salt = salt_buf;
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
char *hook_salts_buf_new_ptr = ((char *) hook_salts_buf_new) + (salts_cnt * hashconfig->hook_salt_size);
@ -1289,7 +1289,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
hashes_buf[0].digest = digests_buf_new_ptr;
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
char *esalts_buf_new_ptr = ((char *) esalts_buf_new) + (0 * hashconfig->esalt_size);
@ -1307,7 +1307,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
for (u32 hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
{
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
{
@ -1317,7 +1317,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
hashes_buf[hashes_pos].salt = salt_buf;
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
char *hook_salts_buf_new_ptr = ((char *) hook_salts_buf_new) + (salts_cnt * hashconfig->hook_salt_size);
@ -1335,7 +1335,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
hashes_buf[hashes_pos].salt = salt_buf;
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
char *hook_salts_buf_new_ptr = ((char *) hook_salts_buf_new) + (salts_cnt * hashconfig->hook_salt_size);
@ -1351,7 +1351,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx)
hashes_buf[hashes_pos].digest = digests_buf_new_ptr;
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
char *esalts_buf_new_ptr = ((char *) esalts_buf_new) + (hashes_pos * hashconfig->esalt_size);
@ -1536,12 +1536,12 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
st_salts_buf = (salt_t *) hccalloc (1, sizeof (salt_t));
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
st_esalts_buf = (void *) hccalloc (1, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
st_hook_salts_buf = (void *) hccalloc (1, hashconfig->hook_salt_size);
}

78
src/interface.c
View File

@ -19699,27 +19699,29 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
user_options_t *user_options = hashcat_ctx->user_options;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
hashconfig->hash_mode = user_options->hash_mode;
hashconfig->hash_type = 0;
hashconfig->salt_type = 0;
hashconfig->attack_exec = 0;
hashconfig->opts_type = 0;
hashconfig->kern_type = 0;
hashconfig->dgst_size = 0;
hashconfig->esalt_size = 0;
hashconfig->hook_salt_size = 0;
hashconfig->tmp_size = 0;
hashconfig->hook_size = 0;
hashconfig->opti_type = 0;
hashconfig->is_salted = 0;
hashconfig->dgst_pos0 = 0;
hashconfig->dgst_pos1 = 0;
hashconfig->dgst_pos2 = 0;
hashconfig->dgst_pos3 = 0;
hashconfig->parse_func = NULL;
hashconfig->separator = user_options->separator;
hashconfig->st_hash = NULL;
hashconfig->st_pass = NULL;
hashconfig->hash_mode = user_options->hash_mode;
hashconfig->hash_type = 0;
hashconfig->salt_type = 0;
hashconfig->attack_exec = 0;
hashconfig->opts_type = 0;
hashconfig->kern_type = 0;
hashconfig->dgst_size = 0;
hashconfig->esalt_size = 0;
hashconfig->hook_salt_size = 0;
hashconfig->tmp_size = 0;
hashconfig->hook_size = 0;
hashconfig->opti_type = 0;
hashconfig->is_salted = false;
hashconfig->has_pure_kernel = false;
hashconfig->has_optimized_kernel = false;
hashconfig->dgst_pos0 = 0;
hashconfig->dgst_pos1 = 0;
hashconfig->dgst_pos2 = 0;
hashconfig->dgst_pos3 = 0;
hashconfig->parse_func = NULL;
hashconfig->separator = user_options->separator;
hashconfig->st_hash = NULL;
hashconfig->st_pass = NULL;
switch (hashconfig->hash_mode)
{
@ -24382,17 +24384,23 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
// some kernels do not have an optimized kernel, simply because they do not need them
// or because they are not yet converted, for them we should switch off optimized mode
char source_file[256] = { 0 };
generate_source_kernel_filename (hashconfig->attack_exec, user_options_extra->attack_kern, hashconfig->kern_type, false, folder_config->shared_dir, source_file);
hashconfig->has_pure_kernel = hc_path_read (source_file);
generate_source_kernel_filename (hashconfig->attack_exec, user_options_extra->attack_kern, hashconfig->kern_type, true, folder_config->shared_dir, source_file);
hashconfig->has_optimized_kernel = hc_path_read (source_file);
if (user_options->example_hashes == false)
{
if (user_options->optimized_kernel_enable == true)
{
char source_file[256] = { 0 };
generate_source_kernel_filename (hashconfig->attack_exec, user_options_extra->attack_kern, hashconfig->kern_type, true, folder_config->shared_dir, source_file);
if (hc_path_read (source_file) == false)
if (hashconfig->has_optimized_kernel == false)
{
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "%s: Optimized OpenCL kernel not support, falling back to pure kernel", source_file);
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "%s: Optimized OpenCL kernel not found, falling back to pure OpenCL kernel", source_file);
}
else
{
@ -24401,13 +24409,9 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
}
else
{
char source_file[256] = { 0 };
generate_source_kernel_filename (hashconfig->attack_exec, user_options_extra->attack_kern, hashconfig->kern_type, false, folder_config->shared_dir, source_file);
if (hc_path_read (source_file) == false)
if (hashconfig->has_pure_kernel == false)
{
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "%s: Pure kernel not found, falling back to optimized kernel", source_file);
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "%s: Pure OpenCL kernel not found, falling back to optimized OpenCL kernel", source_file);
hashconfig->opti_type |= OPTI_TYPE_OPTIMIZED_KERNEL;
}
@ -24442,9 +24446,9 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
hashconfig->opti_type &= ~OPTI_TYPE_APPENDED_SALT;
}
const u32 is_salted = ((hashconfig->salt_type == SALT_TYPE_GENERIC)
| (hashconfig->salt_type == SALT_TYPE_EMBEDDED)
| (hashconfig->salt_type == SALT_TYPE_VIRTUAL));
const bool is_salted = ((hashconfig->salt_type == SALT_TYPE_GENERIC)
| (hashconfig->salt_type == SALT_TYPE_EMBEDDED)
| (hashconfig->salt_type == SALT_TYPE_VIRTUAL));
hashconfig->is_salted = is_salted;
@ -25155,7 +25159,7 @@ void hashconfig_benchmark_defaults (hashcat_ctx_t *hashcat_ctx, salt_t *salt, vo
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
salt->salt_len = 8;

22
src/main.c
View File

@ -476,7 +476,7 @@ static void main_outerloop_mainscreen (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx,
event_log_info (hashcat_ctx, "Password length minimum: %u", hashconfig->pw_min);
event_log_info (hashcat_ctx, "Password length maximum: %u", hashconfig->pw_max);
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
if (hashconfig->opti_type & OPTI_TYPE_RAW_HASH)
{
@ -489,10 +489,13 @@ static void main_outerloop_mainscreen (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx,
if ((hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) == 0)
{
event_log_advice (hashcat_ctx, "ATTENTION! Pure (unoptimized) OpenCL kernels selected.");
event_log_advice (hashcat_ctx, "This enables cracking passwords and salts > length 32 but for the price of drastical reduced performance.");
event_log_advice (hashcat_ctx, "If you want to switch to optimized OpenCL kernels, append -O to your commandline.");
event_log_advice (hashcat_ctx, NULL);
if (hashconfig->has_optimized_kernel == true)
{
event_log_advice (hashcat_ctx, "ATTENTION! Pure (unoptimized) OpenCL kernels selected.");
event_log_advice (hashcat_ctx, "This enables cracking passwords and salts > length 32 but for the price of drastical reduced performance.");
event_log_advice (hashcat_ctx, "If you want to switch to optimized OpenCL kernels, append -O to your commandline.");
event_log_advice (hashcat_ctx, NULL);
}
}
/**
@ -692,9 +695,12 @@ static void main_monitor_performance_hint (MAYBE_UNUSED hashcat_ctx_t *hashcat_c
if ((hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) == 0)
{
event_log_advice (hashcat_ctx, "* Append -O to the commandline.");
event_log_advice (hashcat_ctx, " This lowers the maximum supported password- and salt-length (typically down to 32).");
event_log_advice (hashcat_ctx, NULL);
if (hashconfig->has_optimized_kernel == true)
{
event_log_advice (hashcat_ctx, "* Append -O to the commandline.");
event_log_advice (hashcat_ctx, " This lowers the maximum supported password- and salt-length (typically down to 32).");
event_log_advice (hashcat_ctx, NULL);
}
}
if (user_options->workload_profile < 3)

8
src/outfile_check.c
View File

@ -27,7 +27,7 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
user_options_t *user_options = hashcat_ctx->user_options;
u32 dgst_size = hashconfig->dgst_size;
u32 is_salted = hashconfig->is_salted;
bool is_salted = hashconfig->is_salted;
u32 esalt_size = hashconfig->esalt_size;
u32 hook_salt_size = hashconfig->hook_salt_size;
u32 hash_mode = hashconfig->hash_mode;
@ -41,9 +41,9 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
hash_buf.digest = hcmalloc (dgst_size);
if (is_salted) hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t));
if (esalt_size) hash_buf.esalt = (void *) hcmalloc (esalt_size);
if (hook_salt_size) hash_buf.hook_salt = (void *) hcmalloc (hook_salt_size);
if (is_salted == true) hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t));
if (esalt_size > 0) hash_buf.esalt = (void *) hcmalloc (esalt_size);
if (hook_salt_size > 0) hash_buf.hook_salt = (void *) hcmalloc (hook_salt_size);
u32 digest_buf[64] = { 0 };

22
src/potfile.c
View File

@ -353,17 +353,17 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
hash_buf.hash_info = NULL;
hash_buf.cracked = 0;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
hash_buf.esalt = hcmalloc (hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
hash_buf.hook_salt = hcmalloc (hashconfig->hook_salt_size);
}
@ -421,17 +421,17 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
// we should allow length 0 passwords (detected by weak hash check)
//if (line_pw_len == 0) continue;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
memset (hash_buf.salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
memset (hash_buf.esalt, 0, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
memset (hash_buf.hook_salt, 0, hashconfig->hook_salt_size);
}
@ -477,7 +477,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
if (essid_len > 32) continue;
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
// this should be always true, but we need it to make scan-build happy
@ -514,7 +514,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
if (parser_status == PARSER_OK)
{
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
if (potfile_ctx->keep_all_hashes == true)
{
@ -546,17 +546,17 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
potfile_read_close (hashcat_ctx);
if (hashconfig->esalt_size)
if (hashconfig->esalt_size > 0)
{
hcfree (hash_buf.esalt);
}
if (hashconfig->hook_salt_size)
if (hashconfig->hook_salt_size > 0)
{
hcfree (hash_buf.hook_salt);
}
if (hashconfig->is_salted)
if (hashconfig->is_salted == true)
{
hcfree (hash_buf.salt);
}