From 1c055a6311627858ebb69d40fcab7182b387e6b7 Mon Sep 17 00:00:00 2001 From: jsteube Date: Sun, 23 Oct 2016 14:49:40 +0200 Subject: [PATCH] Move event_log_info() out of hashes.c --- include/types.h | 16 ++++++++ src/hashes.c | 51 ++++++++++++++++------- src/hwmon.c | 2 +- src/main.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++- src/wordlist.c | 4 +- 5 files changed, 161 insertions(+), 19 deletions(-) diff --git a/include/types.h b/include/types.h index 655537fad..180816eae 100644 --- a/include/types.h +++ b/include/types.h @@ -124,6 +124,15 @@ typedef enum event_identifier EVENT_MONITOR_STATUS_REFRESH = 0x000000e1, EVENT_WORDLIST_CACHE_HIT = 0x000000f1, EVENT_WORDLIST_CACHE_GENERATE = 0x000000f2, + EVENT_HASHLIST_COUNT_LINES_PRE = 0x00000101, + EVENT_HASHLIST_COUNT_LINES_POST = 0x00000102, + EVENT_HASHLIST_PARSE_HASH = 0x00000103, + EVENT_HASHLIST_SORT_HASH_PRE = 0x00000104, + EVENT_HASHLIST_SORT_HASH_POST = 0x00000105, + EVENT_HASHLIST_UNIQUE_HASH_PRE = 0x00000106, + EVENT_HASHLIST_UNIQUE_HASH_POST = 0x00000107, + EVENT_HASHLIST_SORT_SALT_PRE = 0x00000108, + EVENT_HASHLIST_SORT_SALT_POST = 0x00000109, // there will be much more event types soon @@ -1469,6 +1478,13 @@ typedef struct cache_generate } cache_generate_t; +typedef struct hashlist_parse +{ + u32 hashes_cnt; + u32 hashes_avail; + +} hashlist_parse_t; + typedef struct event_ctx { char msg_buf[HCBUFSIZ_TINY]; diff --git a/src/hashes.c b/src/hashes.c index 3ff91e0de..b859b862b 100644 --- a/src/hashes.c +++ b/src/hashes.c @@ -322,8 +322,8 @@ int check_cracked (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, if (num_cracked) { // display hack (for weak hashes etc, it could be that there is still something to clear on the current line) - - event_log_info_nn (hashcat_ctx, ""); + // still needed? + //event_log_info_nn (hashcat_ctx, ""); plain_t *cracked = (plain_t *) hccalloc (hashcat_ctx, num_cracked, sizeof (plain_t)); VERIFY_PTR (cracked); @@ -494,10 +494,12 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) return -1; } - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Counting lines in %s", hashfile); + EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_PRE, hashfile, sizeof (hashfile)); hashes_avail = count_lines (hashcat_ctx, fp); + EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_POST, hashfile, sizeof (hashfile)); + rewind (fp); if (hashes_avail == 0) @@ -807,6 +809,9 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); + time_t prev = 0; + time_t now = 0; + while (!feof (fp)) { line_num++; @@ -893,8 +898,6 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) continue; } - if (user_options->quiet == false) if ((hashes_cnt % 0x20000) == 0) event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100); - hashes_cnt++; } else @@ -908,8 +911,6 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) continue; } - if (user_options->quiet == false) if ((hashes_cnt % 0x20000) == 0) event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100); - hashes_cnt++; } } @@ -924,17 +925,33 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) continue; } - if (user_options->quiet == false) if ((hashes_cnt % 0x20000) == 0) event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100); - hashes_cnt++; } + + time (&now); + + if ((now - prev) == 0) continue; + + time (&prev); + + hashlist_parse_t hashlist_parse; + + hashlist_parse.hashes_cnt = hashes_cnt; + hashlist_parse.hashes_avail = hashes_avail; + + EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse)); } + hashlist_parse_t hashlist_parse; + + hashlist_parse.hashes_cnt = hashes_cnt; + hashlist_parse.hashes_avail = hashes_avail; + + EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse)); + hcfree (line_buf); fclose (fp); - - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00); } } @@ -942,7 +959,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) if (hashes_cnt) { - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Sorting Hashes..."); + EVENT (EVENT_HASHLIST_SORT_HASH_PRE); if (hashconfig->is_salted) { @@ -953,7 +970,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt, (void *) hashconfig); } - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Sorted Hashes..."); + EVENT (EVENT_HASHLIST_SORT_HASH_POST); } return 0; @@ -972,7 +989,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) * Remove duplicates */ - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Removing duplicate hashes..."); + EVENT (EVENT_HASHLIST_UNIQUE_HASH_PRE); u32 hashes_cnt_new = 1; @@ -1008,6 +1025,8 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) hashes->hashes_cnt = hashes_cnt; + EVENT (EVENT_HASHLIST_UNIQUE_HASH_POST); + /** * Now generate all the buffers required for later */ @@ -1030,7 +1049,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) salts_buf_new = (salt_t *) hccalloc (hashcat_ctx, 1, sizeof (salt_t)); VERIFY_PTR (salts_buf_new); } - if (user_options->quiet == false) event_log_info_nn (hashcat_ctx, "Structuring salts for cracking task..."); + EVENT (EVENT_HASHLIST_SORT_SALT_PRE); u32 digests_cnt = hashes_cnt; u32 digests_done = 0; @@ -1147,6 +1166,8 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) } } + EVENT (EVENT_HASHLIST_SORT_SALT_POST); + hcfree (hashes->digests_buf); hcfree (hashes->salts_buf); hcfree (hashes->esalts_buf); diff --git a/src/hwmon.c b/src/hwmon.c index e53ea223f..469c9ab38 100644 --- a/src/hwmon.c +++ b/src/hwmon.c @@ -3302,7 +3302,7 @@ void hwmon_ctx_destroy (hashcat_ctx_t *hashcat_ctx) if ((hm_ADL_Overdrive_State_Set (hashcat_ctx, hwmon_ctx->hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) == -1) { - //event_log_info (hashcat_ctx, "Failed to restore ADL performance state"); + //event_log_error (hashcat_ctx, "Failed to restore ADL performance state"); continue; } diff --git a/src/main.c b/src/main.c index eebb29115..8cc3656e8 100644 --- a/src/main.c +++ b/src/main.c @@ -693,7 +693,6 @@ static void main_wordlist_cache_hit (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA event_log_info (hashcat_ctx, ""); } - static void main_wordlist_cache_generate (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) { const user_options_t *user_options = hashcat_ctx->user_options; @@ -713,6 +712,103 @@ static void main_wordlist_cache_generate (MAYBE_UNUSED hashcat_ctx_t *hashcat_ct } } +static void main_hashlist_count_lines_pre (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + char *hashfile = (char *) buf; + + event_log_info_nn (hashcat_ctx, "Counting lines in %s...", hashfile); +} + +static void main_hashlist_count_lines_post (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + char *hashfile = (char *) buf; + + event_log_info_nn (hashcat_ctx, "Counted lines in %s...", hashfile); +} + +static void main_hashlist_parse_hash (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + hashlist_parse_t *hashlist_parse = (hashlist_parse_t *) buf; + + const u32 hashes_cnt = hashlist_parse->hashes_cnt; + const u32 hashes_avail = hashlist_parse->hashes_avail; + + if (hashes_cnt < hashes_avail) + { + event_log_info_nn (hashcat_ctx, "Parsing Hashes: %u/%u (%0.2f%%)...", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100); + } + else + { + event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, 100); + } +} + +static void main_hashlist_sort_hash_pre (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Sorting hashes..."); +} + +static void main_hashlist_sort_hash_post (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Sorted hashes..."); +} + +static void main_hashlist_unique_hash_pre (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Removing duplicate hashes..."); +} + +static void main_hashlist_unique_hash_post (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Removed duplicate hashes..."); +} + +static void main_hashlist_sort_salt_pre (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Sorting salts..."); +} + +static void main_hashlist_sort_salt_post (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) +{ + const user_options_t *user_options = hashcat_ctx->user_options; + + if (user_options->quiet == true) return; + + event_log_info_nn (hashcat_ctx, "Sorted salts..."); +} + void event (const u32 id, hashcat_ctx_t *hashcat_ctx, const void *buf, const size_t len) { switch (id) @@ -750,6 +846,15 @@ void event (const u32 id, hashcat_ctx_t *hashcat_ctx, const void *buf, const siz case EVENT_MONITOR_STATUS_REFRESH: main_monitor_status_refresh (hashcat_ctx, buf, len); break; case EVENT_WORDLIST_CACHE_HIT: main_wordlist_cache_hit (hashcat_ctx, buf, len); break; case EVENT_WORDLIST_CACHE_GENERATE: main_wordlist_cache_generate (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_COUNT_LINES_PRE: main_hashlist_count_lines_pre (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_COUNT_LINES_POST: main_hashlist_count_lines_post (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_PARSE_HASH: main_hashlist_parse_hash (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_SORT_HASH_PRE: main_hashlist_sort_hash_pre (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_SORT_HASH_POST: main_hashlist_sort_hash_post (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_UNIQUE_HASH_PRE: main_hashlist_unique_hash_pre (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_UNIQUE_HASH_POST: main_hashlist_unique_hash_post (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_SORT_SALT_PRE: main_hashlist_sort_salt_pre (hashcat_ctx, buf, len); break; + case EVENT_HASHLIST_SORT_SALT_POST: main_hashlist_sort_salt_post (hashcat_ctx, buf, len); break; } } diff --git a/src/wordlist.c b/src/wordlist.c index daad8b558..30476325e 100644 --- a/src/wordlist.c +++ b/src/wordlist.c @@ -401,6 +401,8 @@ u64 count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile) if ((now - prev) == 0) continue; + time (&prev); + double percent = ((double) comp / (double) d.stat.st_size) * 100; cache_generate_t cache_generate; @@ -412,8 +414,6 @@ u64 count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile) cache_generate.cnt2 = cnt2; EVENT_DATA (EVENT_WORDLIST_CACHE_GENERATE, &cache_generate, sizeof (cache_generate)); - - time (&prev); } cache_generate_t cache_generate;