From 8598a797322ea7e8af6531d4e267f53d57ce2fd0 Mon Sep 17 00:00:00 2001 From: jsteube Date: Thu, 13 Oct 2016 10:07:04 +0200 Subject: [PATCH] Removed exit() from memory.c, resulting in all exit() calls removed from all code in the repository --- include/bitmap.h | 2 +- include/interface.h | 2 +- include/memory.h | 2 + include/potfile.h | 10 +- include/user_options.h | 2 +- include/wordlist.h | 4 +- src/bitmap.c | 32 +++--- src/combinator.c | 2 +- src/cpt.c | 2 +- src/cpu_crc32.c | 2 +- src/dictstat.c | 4 +- src/dispatch.c | 28 +++--- src/filehandling.c | 2 +- src/folder.c | 111 ++++++++++----------- src/hashcat.c | 74 +++++++------- src/hashes.c | 44 ++++----- src/hlfmt.c | 4 +- src/hwmon.c | 46 ++++----- src/induct.c | 4 +- src/interface.c | 12 ++- src/logfile.c | 6 +- src/loopback.c | 2 +- src/main.c | 12 ++- src/memory.c | 10 +- src/monitor.c | 6 +- src/mpsp.c | 218 +++++++++++++++++++++++++---------------- src/opencl.c | 56 +++++------ src/outfile_check.c | 20 ++-- src/potfile.c | 88 ++++++++++------- src/restore.c | 16 +-- src/rp.c | 16 +-- src/status.c | 6 +- src/straight.c | 34 +++++-- src/tuningdb.c | 8 +- src/user_options.c | 6 +- src/wordlist.c | 28 +++--- 36 files changed, 513 insertions(+), 408 deletions(-) diff --git a/include/bitmap.h b/include/bitmap.h index 18b07f329..c12b6889a 100644 --- a/include/bitmap.h +++ b/include/bitmap.h @@ -8,7 +8,7 @@ #include -void bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx); +int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx); void bitmap_ctx_destroy (hashcat_ctx_t *hashcat_ctx); #endif // _BITMAP_H diff --git a/include/interface.h b/include/interface.h index e0f1f69ea..6300c2872 100644 --- a/include/interface.h +++ b/include/interface.h @@ -1507,7 +1507,7 @@ char *strparser (const u32 parser_status); void to_hccap_t (hashcat_ctx_t *hashcat_ctx, hccap_t *hccap, const u32 salt_pos, const u32 digest_pos); -void ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos, const u32 digest_pos); +int ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos, const u32 digest_pos); int hashconfig_init (hashcat_ctx_t *hashcat_ctx); void hashconfig_destroy (hashcat_ctx_t *hashcat_ctx); diff --git a/include/memory.h b/include/memory.h index b8920fa7c..c1193d78c 100644 --- a/include/memory.h +++ b/include/memory.h @@ -12,6 +12,8 @@ #define MSG_ENOMEM "Insufficient memory available" +#define VERIFY_PTR(v) if ((v) == NULL) return -1; + void *hccalloc (hashcat_ctx_t *hashcat_ctx, const size_t nmemb, const size_t sz); void *hcmalloc (hashcat_ctx_t *hashcat_ctx, const size_t sz); void *hcrealloc (hashcat_ctx_t *hashcat_ctx, void *ptr, const size_t oldsz, const size_t addsz); diff --git a/include/potfile.h b/include/potfile.h index 2e5a3264c..85ba9ca1f 100644 --- a/include/potfile.h +++ b/include/potfile.h @@ -22,18 +22,18 @@ void *hc_bsearch_r (const void *key, const void *base, size_t nmemb, size_t size int potfile_init (hashcat_ctx_t *hashcat_ctx); int potfile_read_open (hashcat_ctx_t *hashcat_ctx); -void potfile_read_parse (hashcat_ctx_t *hashcat_ctx); +int potfile_read_parse (hashcat_ctx_t *hashcat_ctx); void potfile_read_close (hashcat_ctx_t *hashcat_ctx); int potfile_write_open (hashcat_ctx_t *hashcat_ctx); void potfile_write_close (hashcat_ctx_t *hashcat_ctx); void potfile_write_append (hashcat_ctx_t *hashcat_ctx, const char *out_buf, u8 *plain_ptr, unsigned int plain_len); -void potfile_hash_alloc (hashcat_ctx_t *hashcat_ctx, const u32 num); +int potfile_hash_alloc (hashcat_ctx_t *hashcat_ctx, const u32 num); void potfile_hash_free (hashcat_ctx_t *hashcat_ctx); void potfile_show_request (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hashes_buf, int (*sort_by_pot) (const void *, const void *, void *)); void potfile_left_request (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hashes_buf, int (*sort_by_pot) (const void *, const void *, void *)); -void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)); -void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)); -void potfile_remove_parse (hashcat_ctx_t *hashcat_ctx); +int potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)); +int potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)); +int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx); void potfile_destroy (hashcat_ctx_t *hashcat_ctx); #endif // _POTFILE_H diff --git a/include/user_options.h b/include/user_options.h index da54d7d49..81271cd48 100644 --- a/include/user_options.h +++ b/include/user_options.h @@ -156,7 +156,7 @@ typedef enum user_options_map } user_options_map_t; -void user_options_init (hashcat_ctx_t *hashcat_ctx); +int user_options_init (hashcat_ctx_t *hashcat_ctx); void user_options_destroy (hashcat_ctx_t *hashcat_ctx); diff --git a/include/wordlist.h b/include/wordlist.h index fa68bf83c..0efa2221e 100644 --- a/include/wordlist.h +++ b/include/wordlist.h @@ -18,9 +18,9 @@ void get_next_word_uc (char *buf, u64 sz, u64 *len, u64 *off); void get_next_word_std (char *buf, u64 sz, u64 *len, u64 *off); void get_next_word (hashcat_ctx_t *hashcat_ctx, FILE *fd, char **out_buf, u32 *out_len); -void load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd); +int load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd); u64 count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile); -void wl_data_init (hashcat_ctx_t *hashcat_ctx); +int wl_data_init (hashcat_ctx_t *hashcat_ctx); void wl_data_destroy (hashcat_ctx_t *hashcat_ctx); #endif // _WORDLIST_H diff --git a/src/bitmap.c b/src/bitmap.c index 9cae87480..82f65e677 100644 --- a/src/bitmap.c +++ b/src/bitmap.c @@ -49,7 +49,7 @@ static u32 generate_bitmaps (const u32 digests_cnt, const u32 dgst_size, const u return collisions; } -void bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) +int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) { bitmap_ctx_t *bitmap_ctx = hashcat_ctx->bitmap_ctx; hashconfig_t *hashconfig = hashcat_ctx->hashconfig; @@ -58,12 +58,12 @@ void bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) bitmap_ctx->enabled = false; - if (user_options->keyspace == true) return; - if (user_options->left == true) return; - if (user_options->opencl_info == true) return; - if (user_options->show == true) return; - if (user_options->usage == true) return; - if (user_options->version == true) return; + if (user_options->keyspace == true) return 0; + if (user_options->left == true) return 0; + if (user_options->opencl_info == true) return 0; + if (user_options->show == true) return 0; + if (user_options->usage == true) return 0; + if (user_options->version == true) return 0; bitmap_ctx->enabled = true; @@ -77,14 +77,14 @@ void bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) const u32 bitmap_min = user_options->bitmap_min; const u32 bitmap_max = user_options->bitmap_max; - u32 *bitmap_s1_a = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s1_b = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s1_c = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s1_d = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s2_a = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s2_b = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s2_c = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); - u32 *bitmap_s2_d = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); + u32 *bitmap_s1_a = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s1_a); + u32 *bitmap_s1_b = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s1_b); + u32 *bitmap_s1_c = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s1_c); + u32 *bitmap_s1_d = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s1_d); + u32 *bitmap_s2_a = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s2_a); + u32 *bitmap_s2_b = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s2_b); + u32 *bitmap_s2_c = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s2_c); + u32 *bitmap_s2_d = (u32 *) hcmalloc (hashcat_ctx, (1u << bitmap_max) * sizeof (u32)); VERIFY_PTR (bitmap_s2_d); u32 bitmap_bits; u32 bitmap_nums; @@ -131,6 +131,8 @@ void bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) bitmap_ctx->bitmap_s2_b = bitmap_s2_b; bitmap_ctx->bitmap_s2_c = bitmap_s2_c; bitmap_ctx->bitmap_s2_d = bitmap_s2_d; + + return 0; } void bitmap_ctx_destroy (hashcat_ctx_t *hashcat_ctx) diff --git a/src/combinator.c b/src/combinator.c index 0db247519..e498e7869 100644 --- a/src/combinator.c +++ b/src/combinator.c @@ -30,7 +30,7 @@ int combinator_ctx_init (hashcat_ctx_t *hashcat_ctx) combinator_ctx->enabled = true; - combinator_ctx->scratch_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + combinator_ctx->scratch_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (combinator_ctx->scratch_buf); if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { diff --git a/src/cpt.c b/src/cpt.c index 8cf5c36b0..9386b5d64 100644 --- a/src/cpt.c +++ b/src/cpt.c @@ -25,7 +25,7 @@ int cpt_ctx_init (hashcat_ctx_t *hashcat_ctx) cpt_ctx->enabled = true; - cpt_ctx->cpt_buf = (cpt_t *) hccalloc (hashcat_ctx, CPT_BUF, sizeof (cpt_t)); + cpt_ctx->cpt_buf = (cpt_t *) hccalloc (hashcat_ctx, CPT_BUF, sizeof (cpt_t)); VERIFY_PTR (cpt_ctx->cpt_buf); cpt_ctx->cpt_total = 0; cpt_ctx->cpt_pos = 0; diff --git a/src/cpu_crc32.c b/src/cpu_crc32.c index 98b248ef0..36a62919d 100644 --- a/src/cpu_crc32.c +++ b/src/cpu_crc32.c @@ -92,7 +92,7 @@ int cpu_crc32 (hashcat_ctx_t *hashcat_ctx, const char *filename, u8 keytab[64]) #define MAX_KEY_SIZE (1024 * 1024) - u8 *buf = (u8 *) hcmalloc (hashcat_ctx, MAX_KEY_SIZE + 1); + u8 *buf = (u8 *) hcmalloc (hashcat_ctx, MAX_KEY_SIZE + 1); VERIFY_PTR (buf); int nread = fread (buf, sizeof (u8), MAX_KEY_SIZE, fd); diff --git a/src/dictstat.c b/src/dictstat.c index 6948fc299..0fbe1961f 100644 --- a/src/dictstat.c +++ b/src/dictstat.c @@ -42,8 +42,8 @@ int dictstat_init (hashcat_ctx_t *hashcat_ctx) if (user_options->attack_mode == ATTACK_MODE_BF) return 0; dictstat_ctx->enabled = true; - dictstat_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); - dictstat_ctx->base = (dictstat_t *) hccalloc (hashcat_ctx, MAX_DICTSTAT, sizeof (dictstat_t)); + dictstat_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (dictstat_ctx->filename); + dictstat_ctx->base = (dictstat_t *) hccalloc (hashcat_ctx, MAX_DICTSTAT, sizeof (dictstat_t)); VERIFY_PTR (dictstat_ctx->base); dictstat_ctx->cnt = 0; snprintf (dictstat_ctx->filename, HCBUFSIZ_TINY - 1, "%s/hashcat.dictstat", folder_config->profile_dir); diff --git a/src/dispatch.c b/src/dispatch.c index 701a6fe49..bb39cd8d0 100644 --- a/src/dispatch.c +++ b/src/dispatch.c @@ -104,7 +104,7 @@ static u32 get_work (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param return work; } -static void calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) +static int calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) { user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; @@ -113,7 +113,7 @@ static void calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_pa straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; - char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (buf); const u32 attack_kern = user_options_extra->attack_kern; @@ -224,6 +224,8 @@ static void calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_pa device_param->kernel_loops = 0; hcfree (buf); + + return 0; } void *thread_calc_stdin (void *p) @@ -240,12 +242,12 @@ void *thread_calc_stdin (void *p) if (device_param->skipped) return NULL; - calc_stdin (hashcat_ctx, device_param); + calc_stdin (hashcat_ctx, device_param); // we should check the RC here return NULL; } -static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) +static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) { user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; @@ -316,7 +318,7 @@ static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) { event_log_error (hashcat_ctx, "%s: %s", dictfile, strerror (errno)); - return; + return -1; } if (attack_mode == ATTACK_MODE_COMBI) @@ -335,7 +337,7 @@ static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) fclose (fd); - return; + return -1; } device_param->combs_fp = combs_fp; @@ -352,14 +354,14 @@ static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) fclose (fd); - return; + return -1; } device_param->combs_fp = combs_fp; } } - hashcat_ctx_t *hashcat_ctx_tmp = (hashcat_ctx_t *) hcmalloc (hashcat_ctx, sizeof (hashcat_ctx_t)); + hashcat_ctx_t *hashcat_ctx_tmp = (hashcat_ctx_t *) hcmalloc (hashcat_ctx, sizeof (hashcat_ctx_t)); VERIFY_PTR (hashcat_ctx_tmp); /* hashcat_ctx_tmp->bitmap_ctx = hashcat_ctx->bitmap_ctx; @@ -389,9 +391,11 @@ static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) memcpy (hashcat_ctx_tmp, hashcat_ctx, sizeof (hashcat_ctx_t)); // yes we actually want to copy these pointers - hashcat_ctx_tmp->wl_data = (wl_data_t *) hcmalloc (hashcat_ctx, sizeof (wl_data_t)); + hashcat_ctx_tmp->wl_data = (wl_data_t *) hcmalloc (hashcat_ctx, sizeof (wl_data_t)); VERIFY_PTR (hashcat_ctx_tmp->wl_data); - wl_data_init (hashcat_ctx_tmp); + const int rc_wl_data_init = wl_data_init (hashcat_ctx_tmp); + + if (rc_wl_data_init == -1) return -1; u64 words_cur = 0; @@ -543,6 +547,8 @@ static void calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param) device_param->kernel_accel = 0; device_param->kernel_loops = 0; + + return 0; } void *thread_calc (void *p) @@ -559,7 +565,7 @@ void *thread_calc (void *p) if (device_param->skipped) return NULL; - calc (hashcat_ctx, device_param); + calc (hashcat_ctx, device_param); // we should check the RC here return NULL; } diff --git a/src/filehandling.c b/src/filehandling.c index 77708b312..67218dba2 100644 --- a/src/filehandling.c +++ b/src/filehandling.c @@ -12,7 +12,7 @@ u64 count_lines (hashcat_ctx_t *hashcat_ctx, FILE *fd) { u64 cnt = 0; - char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE + 1); + char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE + 1); VERIFY_PTR (buf); char prev = '\n'; diff --git a/src/folder.c b/src/folder.c index 5c09b1e2c..a3d41a34a 100644 --- a/src/folder.c +++ b/src/folder.c @@ -26,29 +26,25 @@ int sort_by_stringptr (const void *p1, const void *p2) return strcmp (*s1, *s2); } -static char *get_exec_path (hashcat_ctx_t *hashcat_ctx) +static int get_exec_path (char *exec_path, const size_t exec_path_sz) { - size_t exec_path_len = 1024; - - char *exec_path = (char *) hcmalloc (hashcat_ctx, exec_path_len); - #if defined (__linux__) char tmp[32] = { 0 }; snprintf (tmp, sizeof (tmp) - 1, "/proc/%d/exe", getpid ()); - const int len = readlink (tmp, exec_path, exec_path_len - 1); + const int len = readlink (tmp, exec_path, exec_path_sz - 1); #elif defined (_WIN) - const int len = GetModuleFileName (NULL, exec_path, exec_path_len - 1); + const int len = GetModuleFileName (NULL, exec_path, exec_path_sz - 1); #elif defined (__APPLE__) - u32 size = (u32) exec_path_len; + u32 size = (u32) exec_path_sz; - if (_NSGetExecutablePath (exec_path, &size) != 0) return NULL; + if (_NSGetExecutablePath (exec_path, &size) != 0) return -1; const size_t len = strlen (exec_path); @@ -63,11 +59,11 @@ static char *get_exec_path (hashcat_ctx_t *hashcat_ctx) char tmp[32] = { 0 }; - size_t size = exec_path_len; + size_t size = exec_path_sz; sysctl (mib, 4, exec_path, &size, NULL, 0); - const int len = readlink (tmp, exec_path, exec_path_len - 1); + const int len = readlink (tmp, exec_path, exec_path_sz - 1); #else #error Your Operating System is not supported or detected @@ -75,13 +71,14 @@ static char *get_exec_path (hashcat_ctx_t *hashcat_ctx) exec_path[len] = 0; - return exec_path; + return 0; } -char *get_install_dir (hashcat_ctx_t *hashcat_ctx, const char *progname) +static void get_install_dir (char *install_dir, const char *exec_path) { - char *install_dir = hcstrdup (hashcat_ctx, progname); - char *last_slash = NULL; + strncpy (install_dir, exec_path, HCBUFSIZ_TINY - 1); + + char *last_slash = NULL; if ((last_slash = strrchr (install_dir, '/')) != NULL) { @@ -96,26 +93,16 @@ char *get_install_dir (hashcat_ctx_t *hashcat_ctx, const char *progname) install_dir[0] = '.'; install_dir[1] = 0; } - - return (install_dir); } -char *get_profile_dir (hashcat_ctx_t *hashcat_ctx, const char *homedir) +static void get_profile_dir (char *profile_dir, const char *home_dir) { - char *profile_dir = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY + 1); - - snprintf (profile_dir, HCBUFSIZ_TINY - 1, "%s/%s", homedir, DOT_HASHCAT); - - return profile_dir; + snprintf (profile_dir, HCBUFSIZ_TINY - 1, "%s/%s", home_dir, DOT_HASHCAT); } -char *get_session_dir (hashcat_ctx_t *hashcat_ctx, const char *profile_dir) +static void get_session_dir (char *session_dir, const char *profile_dir) { - char *session_dir = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); - snprintf (session_dir, HCBUFSIZ_TINY - 1, "%s/%s", profile_dir, SESSIONS_FOLDER); - - return session_dir; } int count_dictionaries (char **dictionary_files) @@ -147,7 +134,7 @@ char **scan_directory (hashcat_ctx_t *hashcat_ctx, const char *path) char **files = NULL; - int num_files = 0; + size_t num_files = 0; DIR *d = NULL; @@ -178,13 +165,9 @@ char **scan_directory (hashcat_ctx_t *hashcat_ctx, const char *path) if ((strcmp (de->d_name, ".") == 0) || (strcmp (de->d_name, "..") == 0)) continue; - size_t path_size = strlen (tmp_path) + 1 + strlen (de->d_name); + char *path_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); - char *path_file = (char *) hcmalloc (hashcat_ctx, path_size + 1); - - snprintf (path_file, path_size + 1, "%s/%s", tmp_path, de->d_name); - - path_file[path_size] = 0; + snprintf (path_file, HCBUFSIZ_TINY - 1, "%s/%s", tmp_path, de->d_name); DIR *d_test; @@ -196,11 +179,11 @@ char **scan_directory (hashcat_ctx_t *hashcat_ctx, const char *path) } else { - files = (char **) hcrealloc (hashcat_ctx, files, (size_t) num_files * sizeof (char *), sizeof (char *)); + files = (char **) hcrealloc (hashcat_ctx, files, (num_files + 1) * sizeof (char *), sizeof (char *)); + + files[num_files] = path_file; num_files++; - - files[num_files - 1] = path_file; } } @@ -208,19 +191,19 @@ char **scan_directory (hashcat_ctx_t *hashcat_ctx, const char *path) } else if (errno == ENOTDIR) { - files = (char **) hcrealloc (hashcat_ctx, files, (size_t) num_files * sizeof (char *), sizeof (char *)); + files = (char **) hcrealloc (hashcat_ctx, files, (num_files + 1) * sizeof (char *), sizeof (char *)); + + files[num_files] = hcstrdup (hashcat_ctx, path); num_files++; - - files[num_files - 1] = hcstrdup (hashcat_ctx, path); } - files = (char **) hcrealloc (hashcat_ctx, files, (size_t) num_files * sizeof (char *), sizeof (char *)); + files = (char **) hcrealloc (hashcat_ctx, files, (num_files + 1) * sizeof (char *), sizeof (char *)); + + files[num_files] = NULL; num_files++; - files[num_files - 1] = NULL; - hcfree (tmp_path); return (files); @@ -237,7 +220,7 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins * then chdir() back to where we came from so we need to save it first */ - char *cwd = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *cwd = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (cwd); if (getcwd (cwd, HCBUFSIZ_TINY - 1) == NULL) { @@ -250,9 +233,13 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins * folders, as discussed on https://github.com/hashcat/hashcat/issues/20 */ - char *exec_path = get_exec_path (hashcat_ctx); + const size_t exec_path_sz = 1024; - if (exec_path == NULL) + char *exec_path = (char *) hcmalloc (hashcat_ctx, exec_path_sz); VERIFY_PTR (exec_path); + + const int rc = get_exec_path (exec_path, exec_path_sz); + + if (rc == -1) { event_log_error (hashcat_ctx, "get_exec_path() failed"); @@ -280,7 +267,10 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins return -1; } - char *install_dir = get_install_dir (hashcat_ctx, resolved_exec_path); + char *install_dir = hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (install_dir); + + get_install_dir (install_dir, resolved_exec_path); + char *profile_dir = NULL; char *session_dir = NULL; char *shared_dir = NULL; @@ -289,11 +279,15 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins { struct passwd *pw = getpwuid (getuid ()); - const char *homedir = pw->pw_dir; + const char *home_dir = pw->pw_dir; - profile_dir = get_profile_dir (hashcat_ctx, homedir); - session_dir = get_session_dir (hashcat_ctx, profile_dir); - shared_dir = hcstrdup (hashcat_ctx, shared_folder); + profile_dir = hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (profile_dir); + session_dir = hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (session_dir); + + get_profile_dir (profile_dir, home_dir); + get_session_dir (session_dir, profile_dir); + + shared_dir = hcstrdup (hashcat_ctx, shared_folder); hc_mkdir (profile_dir, 0700); hc_mkdir (session_dir, 0700); @@ -310,7 +304,10 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins #else - char *install_dir = get_install_dir (hashcat_ctx, exec_path); + char *install_dir = hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (install_dir); + + get_install_dir (install_dir, exec_path); + char *profile_dir = install_dir; char *session_dir = install_dir; char *shared_dir = install_dir; @@ -326,13 +323,13 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins * The best workaround found so far is to modify the TMP variable (only inside hashcat process) before the runtime is load */ - char *cpath = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *cpath = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (cpath); #if defined (_WIN) snprintf (cpath, HCBUFSIZ_TINY - 1, "%s\\OpenCL\\", shared_dir); - char *cpath_real = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *cpath_real = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (cpath_real); if (GetFullPathName (cpath, HCBUFSIZ_TINY - 1, cpath_real, NULL) == 0) { @@ -345,7 +342,7 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins snprintf (cpath, HCBUFSIZ_TINY - 1, "%s/OpenCL/", shared_dir); - char *cpath_real = (char *) hcmalloc (hashcat_ctx, PATH_MAX); + char *cpath_real = (char *) hcmalloc (hashcat_ctx, PATH_MAX); VERIFY_PTR (cpath_real); if (realpath (cpath, cpath_real) == NULL) { @@ -385,7 +382,7 @@ int folder_config_init (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char *ins * kernel cache, we need to make sure folder exist */ - char *kernels_folder = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *kernels_folder = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (kernels_folder); snprintf (kernels_folder, HCBUFSIZ_TINY - 1, "%s/kernels", profile_dir); diff --git a/src/hashcat.c b/src/hashcat.c index e12f95c5a..f532ee365 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -66,32 +66,32 @@ int hashcat_ctx_init (hashcat_ctx_t *hashcat_ctx, void (*event) (const u32, stru hashcat_ctx->event = event; - hashcat_ctx->bitmap_ctx = (bitmap_ctx_t *) hcmalloc (hashcat_ctx, sizeof (bitmap_ctx_t)); - hashcat_ctx->combinator_ctx = (combinator_ctx_t *) hcmalloc (hashcat_ctx, sizeof (combinator_ctx_t)); - hashcat_ctx->cpt_ctx = (cpt_ctx_t *) hcmalloc (hashcat_ctx, sizeof (cpt_ctx_t)); - hashcat_ctx->debugfile_ctx = (debugfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (debugfile_ctx_t)); - hashcat_ctx->dictstat_ctx = (dictstat_ctx_t *) hcmalloc (hashcat_ctx, sizeof (dictstat_ctx_t)); - hashcat_ctx->event_ctx = (event_ctx_t *) hcmalloc (hashcat_ctx, sizeof (event_ctx_t)); - hashcat_ctx->folder_config = (folder_config_t *) hcmalloc (hashcat_ctx, sizeof (folder_config_t)); - hashcat_ctx->hashcat_user = (hashcat_user_t *) hcmalloc (hashcat_ctx, sizeof (hashcat_user_t)); - hashcat_ctx->hashconfig = (hashconfig_t *) hcmalloc (hashcat_ctx, sizeof (hashconfig_t)); - hashcat_ctx->hashes = (hashes_t *) hcmalloc (hashcat_ctx, sizeof (hashes_t)); - hashcat_ctx->hwmon_ctx = (hwmon_ctx_t *) hcmalloc (hashcat_ctx, sizeof (hwmon_ctx_t)); - hashcat_ctx->induct_ctx = (induct_ctx_t *) hcmalloc (hashcat_ctx, sizeof (induct_ctx_t)); - hashcat_ctx->logfile_ctx = (logfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (logfile_ctx_t)); - hashcat_ctx->loopback_ctx = (loopback_ctx_t *) hcmalloc (hashcat_ctx, sizeof (loopback_ctx_t)); - hashcat_ctx->mask_ctx = (mask_ctx_t *) hcmalloc (hashcat_ctx, sizeof (mask_ctx_t)); - hashcat_ctx->opencl_ctx = (opencl_ctx_t *) hcmalloc (hashcat_ctx, sizeof (opencl_ctx_t)); - hashcat_ctx->outcheck_ctx = (outcheck_ctx_t *) hcmalloc (hashcat_ctx, sizeof (outcheck_ctx_t)); - hashcat_ctx->outfile_ctx = (outfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (outfile_ctx_t)); - hashcat_ctx->potfile_ctx = (potfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (potfile_ctx_t)); - hashcat_ctx->restore_ctx = (restore_ctx_t *) hcmalloc (hashcat_ctx, sizeof (restore_ctx_t)); - hashcat_ctx->status_ctx = (status_ctx_t *) hcmalloc (hashcat_ctx, sizeof (status_ctx_t)); - hashcat_ctx->straight_ctx = (straight_ctx_t *) hcmalloc (hashcat_ctx, sizeof (straight_ctx_t)); - hashcat_ctx->tuning_db = (tuning_db_t *) hcmalloc (hashcat_ctx, sizeof (tuning_db_t)); - hashcat_ctx->user_options_extra = (user_options_extra_t *) hcmalloc (hashcat_ctx, sizeof (user_options_extra_t)); - hashcat_ctx->user_options = (user_options_t *) hcmalloc (hashcat_ctx, sizeof (user_options_t)); - hashcat_ctx->wl_data = (wl_data_t *) hcmalloc (hashcat_ctx, sizeof (wl_data_t)); + hashcat_ctx->bitmap_ctx = (bitmap_ctx_t *) hcmalloc (hashcat_ctx, sizeof (bitmap_ctx_t)); VERIFY_PTR (hashcat_ctx->bitmap_ctx); + hashcat_ctx->combinator_ctx = (combinator_ctx_t *) hcmalloc (hashcat_ctx, sizeof (combinator_ctx_t)); VERIFY_PTR (hashcat_ctx->combinator_ctx); + hashcat_ctx->cpt_ctx = (cpt_ctx_t *) hcmalloc (hashcat_ctx, sizeof (cpt_ctx_t)); VERIFY_PTR (hashcat_ctx->cpt_ctx); + hashcat_ctx->debugfile_ctx = (debugfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (debugfile_ctx_t)); VERIFY_PTR (hashcat_ctx->debugfile_ctx); + hashcat_ctx->dictstat_ctx = (dictstat_ctx_t *) hcmalloc (hashcat_ctx, sizeof (dictstat_ctx_t)); VERIFY_PTR (hashcat_ctx->dictstat_ctx); + hashcat_ctx->event_ctx = (event_ctx_t *) hcmalloc (hashcat_ctx, sizeof (event_ctx_t)); VERIFY_PTR (hashcat_ctx->event_ctx); + hashcat_ctx->folder_config = (folder_config_t *) hcmalloc (hashcat_ctx, sizeof (folder_config_t)); VERIFY_PTR (hashcat_ctx->folder_config); + hashcat_ctx->hashcat_user = (hashcat_user_t *) hcmalloc (hashcat_ctx, sizeof (hashcat_user_t)); VERIFY_PTR (hashcat_ctx->hashcat_user); + hashcat_ctx->hashconfig = (hashconfig_t *) hcmalloc (hashcat_ctx, sizeof (hashconfig_t)); VERIFY_PTR (hashcat_ctx->hashconfig); + hashcat_ctx->hashes = (hashes_t *) hcmalloc (hashcat_ctx, sizeof (hashes_t)); VERIFY_PTR (hashcat_ctx->hashes); + hashcat_ctx->hwmon_ctx = (hwmon_ctx_t *) hcmalloc (hashcat_ctx, sizeof (hwmon_ctx_t)); VERIFY_PTR (hashcat_ctx->hwmon_ctx); + hashcat_ctx->induct_ctx = (induct_ctx_t *) hcmalloc (hashcat_ctx, sizeof (induct_ctx_t)); VERIFY_PTR (hashcat_ctx->induct_ctx); + hashcat_ctx->logfile_ctx = (logfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (logfile_ctx_t)); VERIFY_PTR (hashcat_ctx->logfile_ctx); + hashcat_ctx->loopback_ctx = (loopback_ctx_t *) hcmalloc (hashcat_ctx, sizeof (loopback_ctx_t)); VERIFY_PTR (hashcat_ctx->loopback_ctx); + hashcat_ctx->mask_ctx = (mask_ctx_t *) hcmalloc (hashcat_ctx, sizeof (mask_ctx_t)); VERIFY_PTR (hashcat_ctx->mask_ctx); + hashcat_ctx->opencl_ctx = (opencl_ctx_t *) hcmalloc (hashcat_ctx, sizeof (opencl_ctx_t)); VERIFY_PTR (hashcat_ctx->opencl_ctx); + hashcat_ctx->outcheck_ctx = (outcheck_ctx_t *) hcmalloc (hashcat_ctx, sizeof (outcheck_ctx_t)); VERIFY_PTR (hashcat_ctx->outcheck_ctx); + hashcat_ctx->outfile_ctx = (outfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (outfile_ctx_t)); VERIFY_PTR (hashcat_ctx->outfile_ctx); + hashcat_ctx->potfile_ctx = (potfile_ctx_t *) hcmalloc (hashcat_ctx, sizeof (potfile_ctx_t)); VERIFY_PTR (hashcat_ctx->potfile_ctx); + hashcat_ctx->restore_ctx = (restore_ctx_t *) hcmalloc (hashcat_ctx, sizeof (restore_ctx_t)); VERIFY_PTR (hashcat_ctx->restore_ctx); + hashcat_ctx->status_ctx = (status_ctx_t *) hcmalloc (hashcat_ctx, sizeof (status_ctx_t)); VERIFY_PTR (hashcat_ctx->status_ctx); + hashcat_ctx->straight_ctx = (straight_ctx_t *) hcmalloc (hashcat_ctx, sizeof (straight_ctx_t)); VERIFY_PTR (hashcat_ctx->straight_ctx); + hashcat_ctx->tuning_db = (tuning_db_t *) hcmalloc (hashcat_ctx, sizeof (tuning_db_t)); VERIFY_PTR (hashcat_ctx->tuning_db); + hashcat_ctx->user_options_extra = (user_options_extra_t *) hcmalloc (hashcat_ctx, sizeof (user_options_extra_t)); VERIFY_PTR (hashcat_ctx->user_options_extra); + hashcat_ctx->user_options = (user_options_t *) hcmalloc (hashcat_ctx, sizeof (user_options_t)); VERIFY_PTR (hashcat_ctx->user_options); + hashcat_ctx->wl_data = (wl_data_t *) hcmalloc (hashcat_ctx, sizeof (wl_data_t)); VERIFY_PTR (hashcat_ctx->wl_data); return 0; } @@ -231,9 +231,9 @@ static int inner2_loop (hashcat_ctx_t *hashcat_ctx) EVENT (EVENT_AUTOTUNE_STARTING); - thread_param_t *threads_param = (thread_param_t *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (thread_param_t)); + thread_param_t *threads_param = (thread_param_t *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (thread_param_t)); VERIFY_PTR (threads_param); - hc_thread_t *c_threads = (hc_thread_t *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (hc_thread_t)); + hc_thread_t *c_threads = (hc_thread_t *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (hc_thread_t)); VERIFY_PTR (c_threads); status_ctx->devices_status = STATUS_AUTOTUNE; @@ -475,8 +475,12 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx) { outfile_write_open (hashcat_ctx); - potfile_read_open (hashcat_ctx); - potfile_read_parse (hashcat_ctx); + potfile_read_open (hashcat_ctx); + + const int rc = potfile_read_parse (hashcat_ctx); + + if (rc == -1) return -1; + potfile_read_close (hashcat_ctx); } @@ -567,7 +571,9 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx) EVENT (EVENT_BITMAP_INIT_PRE); - bitmap_ctx_init (hashcat_ctx); + const int rc_bitmap_init = bitmap_ctx_init (hashcat_ctx); + + if (rc_bitmap_init == -1) return -1; EVENT (EVENT_BITMAP_INIT_POST); @@ -581,7 +587,9 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx) * Wordlist allocate buffer */ - wl_data_init (hashcat_ctx); + const int rc_wl_data_init = wl_data_init (hashcat_ctx); + + if (rc_wl_data_init == -1) return -1; /** * straight mode init @@ -700,7 +708,7 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx) int inner_threads_cnt = 0; - hc_thread_t *inner_threads = (hc_thread_t *) hccalloc (hashcat_ctx, 10, sizeof (hc_thread_t)); + hc_thread_t *inner_threads = (hc_thread_t *) hccalloc (hashcat_ctx, 10, sizeof (hc_thread_t)); VERIFY_PTR (inner_threads); status_ctx->shutdown_inner = false; diff --git a/src/hashes.c b/src/hashes.c index b70af831f..832a979fc 100644 --- a/src/hashes.c +++ b/src/hashes.c @@ -339,7 +339,7 @@ int check_cracked (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, event_log_info_nn (hashcat_ctx, ""); - plain_t *cracked = (plain_t *) hccalloc (hashcat_ctx, num_cracked, sizeof (plain_t)); + plain_t *cracked = (plain_t *) hccalloc (hashcat_ctx, num_cracked, sizeof (plain_t)); VERIFY_PTR (cracked); CL_err = hc_clEnqueueReadBuffer (hashcat_ctx, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL); @@ -558,9 +558,9 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) salt_t *salts_buf = NULL; void *esalts_buf = NULL; - hashes_buf = (hash_t *) hccalloc (hashcat_ctx, hashes_avail, sizeof (hash_t)); + hashes_buf = (hash_t *) hccalloc (hashcat_ctx, hashes_avail, sizeof (hash_t)); VERIFY_PTR (hashes_buf); - digests_buf = (void *) hccalloc (hashcat_ctx, hashes_avail, hashconfig->dgst_size); + digests_buf = (void *) hccalloc (hashcat_ctx, hashes_avail, hashconfig->dgst_size); VERIFY_PTR (digests_buf); if ((user_options->username && (user_options->remove || user_options->show)) || (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)) { @@ -568,34 +568,34 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++) { - hashinfo_t *hash_info = (hashinfo_t *) hcmalloc (hashcat_ctx, sizeof (hashinfo_t)); + hashinfo_t *hash_info = (hashinfo_t *) hcmalloc (hashcat_ctx, sizeof (hashinfo_t)); VERIFY_PTR (hash_info); hashes_buf[hash_pos].hash_info = hash_info; if (user_options->username && (user_options->remove || user_options->show || user_options->left)) { - hash_info->user = (user_t*) hcmalloc (hashcat_ctx, sizeof (user_t)); + hash_info->user = (user_t*) hcmalloc (hashcat_ctx, sizeof (user_t)); VERIFY_PTR (hash_info->user); } if (user_options->benchmark) { - hash_info->orighash = (char *) hcmalloc (hashcat_ctx, 256); + hash_info->orighash = (char *) hcmalloc (hashcat_ctx, 256); VERIFY_PTR (hash_info->orighash); } } } if (hashconfig->is_salted) { - salts_buf = (salt_t *) hccalloc (hashcat_ctx, hashes_avail, sizeof (salt_t)); + salts_buf = (salt_t *) hccalloc (hashcat_ctx, hashes_avail, sizeof (salt_t)); VERIFY_PTR (salts_buf); if (hashconfig->esalt_size) { - esalts_buf = (void *) hccalloc (hashcat_ctx, hashes_avail, hashconfig->esalt_size); + esalts_buf = (void *) hccalloc (hashcat_ctx, hashes_avail, hashconfig->esalt_size); VERIFY_PTR (esalts_buf); } } else { - salts_buf = (salt_t *) hccalloc (hashcat_ctx, 1, sizeof (salt_t)); + salts_buf = (salt_t *) hccalloc (hashcat_ctx, 1, sizeof (salt_t)); VERIFY_PTR (salts_buf); } for (u32 hash_pos = 0; hash_pos < hashes_avail; hash_pos++) @@ -720,7 +720,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) u32 hccap_size = sizeof (hccap_t); - char *in = (char *) hcmalloc (hashcat_ctx, hccap_size); + char *in = (char *) hcmalloc (hashcat_ctx, hccap_size); VERIFY_PTR (in); while (!feof (fp)) { @@ -891,7 +891,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) u32 line_num = 0; - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (fp)) { @@ -929,7 +929,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx) { user_t **user = &hashes_buf[hashes_cnt].hash_info->user; - *user = (user_t *) hcmalloc (hashcat_ctx, sizeof (user_t)); + *user = (user_t *) hcmalloc (hashcat_ctx, sizeof (user_t)); VERIFY_PTR (*user); user_t *user_ptr = *user; @@ -1108,22 +1108,22 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) * Now generate all the buffers required for later */ - void *digests_buf_new = (void *) hccalloc (hashcat_ctx, hashes_cnt, hashconfig->dgst_size); + void *digests_buf_new = (void *) hccalloc (hashcat_ctx, hashes_cnt, hashconfig->dgst_size); VERIFY_PTR (digests_buf_new); salt_t *salts_buf_new = NULL; void *esalts_buf_new = NULL; if (hashconfig->is_salted) { - salts_buf_new = (salt_t *) hccalloc (hashcat_ctx, hashes_cnt, sizeof (salt_t)); + salts_buf_new = (salt_t *) hccalloc (hashcat_ctx, hashes_cnt, sizeof (salt_t)); VERIFY_PTR (salts_buf_new); if (hashconfig->esalt_size) { - esalts_buf_new = (void *) hccalloc (hashcat_ctx, hashes_cnt, hashconfig->esalt_size); + esalts_buf_new = (void *) hccalloc (hashcat_ctx, hashes_cnt, hashconfig->esalt_size); VERIFY_PTR (esalts_buf_new); } } else { - salts_buf_new = (salt_t *) hccalloc (hashcat_ctx, 1, sizeof (salt_t)); + 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..."); @@ -1131,8 +1131,8 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) u32 digests_cnt = hashes_cnt; u32 digests_done = 0; - u32 *digests_shown = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); - u32 *digests_shown_tmp = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); + u32 *digests_shown = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); VERIFY_PTR (digests_shown); + u32 *digests_shown_tmp = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); VERIFY_PTR (digests_shown_tmp); u32 salts_cnt = 0; u32 salts_done = 0; @@ -1141,7 +1141,7 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) if ((user_options->username && (user_options->remove || user_options->show)) || (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)) { - hash_info = (hashinfo_t **) hccalloc (hashcat_ctx, hashes_cnt, sizeof (hashinfo_t *)); + hash_info = (hashinfo_t **) hccalloc (hashcat_ctx, hashes_cnt, sizeof (hashinfo_t *)); VERIFY_PTR (hash_info); if (user_options->username && (user_options->remove || user_options->show)) { @@ -1149,14 +1149,14 @@ int hashes_init_stage2 (hashcat_ctx_t *hashcat_ctx) for (user_pos = 0; user_pos < hashes_cnt; user_pos++) { - hash_info[user_pos] = (hashinfo_t *) hccalloc (hashcat_ctx, hashes_cnt, sizeof (hashinfo_t)); + hash_info[user_pos] = (hashinfo_t *) hccalloc (hashcat_ctx, hashes_cnt, sizeof (hashinfo_t)); VERIFY_PTR (hash_info[user_pos]); - hash_info[user_pos]->user = (user_t *) hcmalloc (hashcat_ctx, sizeof (user_t)); + hash_info[user_pos]->user = (user_t *) hcmalloc (hashcat_ctx, sizeof (user_t)); VERIFY_PTR (hash_info[user_pos]->user); } } } - u32 *salts_shown = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); + u32 *salts_shown = (u32 *) hccalloc (hashcat_ctx, digests_cnt, sizeof (u32)); VERIFY_PTR (salts_shown); salt_t *salt_buf; diff --git a/src/hlfmt.c b/src/hlfmt.c index 9cad42409..835092eda 100644 --- a/src/hlfmt.c +++ b/src/hlfmt.c @@ -342,11 +342,11 @@ u32 hlfmt_detect (hashcat_ctx_t *hashcat_ctx, FILE *fp, u32 max_check) if (hashconfig->hash_mode == 5300) return HLFMT_HASHCAT; if (hashconfig->hash_mode == 5400) return HLFMT_HASHCAT; - u32 *formats_cnt = (u32 *) hccalloc (hashcat_ctx, HLFMTS_CNT, sizeof (u32)); + u32 *formats_cnt = (u32 *) hccalloc (hashcat_ctx, HLFMTS_CNT, sizeof (u32)); VERIFY_PTR (formats_cnt); u32 num_check = 0; - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (fp)) { diff --git a/src/hwmon.c b/src/hwmon.c index 7a8375e5a..e53ea223f 100644 --- a/src/hwmon.c +++ b/src/hwmon.c @@ -29,7 +29,7 @@ static int nvml_init (hashcat_ctx_t *hashcat_ctx) DWORD Type = REG_SZ; - char *Buffer = (char *) hcmalloc (hashcat_ctx, BufferSize + 1); + char *Buffer = (char *) hcmalloc (hashcat_ctx, BufferSize + 1); VERIFY_PTR (Buffer); HKEY hKey = 0; @@ -1861,15 +1861,9 @@ static int get_adapters_num_adl (hashcat_ctx_t *hashcat_ctx, int *iNumberAdapter return 0; } -static LPAdapterInfo hm_get_adapter_info_adl (hashcat_ctx_t *hashcat_ctx, int iNumberAdapters) +static int hm_get_adapter_info_adl (hashcat_ctx_t *hashcat_ctx, LPAdapterInfo lpAdapterInfo, const size_t AdapterInfoSize) { - size_t AdapterInfoSize = iNumberAdapters * sizeof (AdapterInfo); - - LPAdapterInfo lpAdapterInfo = (LPAdapterInfo) hcmalloc (hashcat_ctx, AdapterInfoSize); - - if (hm_ADL_Adapter_AdapterInfo_Get (hashcat_ctx, lpAdapterInfo, AdapterInfoSize) == -1) return NULL; - - return lpAdapterInfo; + return hm_ADL_Adapter_AdapterInfo_Get (hashcat_ctx, lpAdapterInfo, AdapterInfoSize); } static int hm_get_adapter_index_nvapi (hashcat_ctx_t *hashcat_ctx, HM_ADAPTER_NVAPI *nvapiGPUHandle) @@ -2001,14 +1995,14 @@ static u32 *hm_get_list_valid_adl_adapters (hashcat_ctx_t *hashcat_ctx, int iNum // add it to the list - adl_adapters = (u32 *) hcrealloc (hashcat_ctx, adl_adapters, (*num_adl_adapters) * sizeof (int), sizeof (int)); + adl_adapters = (u32 *) hcrealloc (hashcat_ctx, adl_adapters, (*num_adl_adapters) * sizeof (int), sizeof (int)); // need check adl_adapters[*num_adl_adapters] = i; // rest is just bookkeeping - bus_numbers = (int*) hcrealloc (hashcat_ctx, bus_numbers, (*num_adl_adapters) * sizeof (int), sizeof (int)); - device_numbers = (int*) hcrealloc (hashcat_ctx, device_numbers, (*num_adl_adapters) * sizeof (int), sizeof (int)); + bus_numbers = (int*) hcrealloc (hashcat_ctx, bus_numbers, (*num_adl_adapters) * sizeof (int), sizeof (int)); // need check + device_numbers = (int*) hcrealloc (hashcat_ctx, device_numbers, (*num_adl_adapters) * sizeof (int), sizeof (int)); // need check bus_numbers[*num_adl_adapters] = info.iBusNumber; device_numbers[*num_adl_adapters] = info.iDeviceNumber; @@ -2732,7 +2726,7 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) if (user_options->version == true) return 0; if (user_options->gpu_temp_disable == true) return 0; - hwmon_ctx->hm_device = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); + hwmon_ctx->hm_device = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); VERIFY_PTR (hwmon_ctx->hm_device); /** * Initialize shared libraries @@ -2743,10 +2737,10 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) NVML_PTR *nvml = (NVML_PTR *) hcmalloc (hashcat_ctx, sizeof (NVML_PTR)); XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) hcmalloc (hashcat_ctx, sizeof (XNVCTRL_PTR)); - hm_attrs_t *hm_adapters_adl = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); - hm_attrs_t *hm_adapters_nvapi = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); - hm_attrs_t *hm_adapters_nvml = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); - hm_attrs_t *hm_adapters_xnvctrl = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); + hm_attrs_t *hm_adapters_adl = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); VERIFY_PTR (hm_adapters_adl); + hm_attrs_t *hm_adapters_nvapi = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); VERIFY_PTR (hm_adapters_nvapi); + hm_attrs_t *hm_adapters_nvml = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); VERIFY_PTR (hm_adapters_nvml); + hm_attrs_t *hm_adapters_xnvctrl = (hm_attrs_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hm_attrs_t)); VERIFY_PTR (hm_adapters_xnvctrl); if (opencl_ctx->need_nvml == true) { @@ -2800,7 +2794,7 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) { if (hm_NVML_nvmlInit (hashcat_ctx) == 0) { - HM_ADAPTER_NVML *nvmlGPUHandle = (HM_ADAPTER_NVML *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (HM_ADAPTER_NVML)); + HM_ADAPTER_NVML *nvmlGPUHandle = (HM_ADAPTER_NVML *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (HM_ADAPTER_NVML)); VERIFY_PTR (nvmlGPUHandle); int tmp_in = hm_get_adapter_index_nvml (hashcat_ctx, nvmlGPUHandle); @@ -2830,7 +2824,7 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) { if (hm_NvAPI_Initialize (hashcat_ctx) == 0) { - HM_ADAPTER_NVAPI *nvGPUHandle = (HM_ADAPTER_NVAPI *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (HM_ADAPTER_NVAPI)); + HM_ADAPTER_NVAPI *nvGPUHandle = (HM_ADAPTER_NVAPI *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (HM_ADAPTER_NVAPI)); VERIFY_PTR (nvGPUHandle); int tmp_in = hm_get_adapter_index_nvapi (hashcat_ctx, nvGPUHandle); @@ -2876,9 +2870,11 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) // adapter info - LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (hashcat_ctx, hm_adapters_num); + LPAdapterInfo lpAdapterInfo = (LPAdapterInfo) hccalloc (hashcat_ctx, hm_adapters_num, sizeof (AdapterInfo)); VERIFY_PTR (lpAdapterInfo); - if (lpAdapterInfo == NULL) return -1; + const int rc_adapter_info_adl = hm_get_adapter_info_adl (hashcat_ctx, lpAdapterInfo, hm_adapters_num * sizeof (AdapterInfo)); + + if (rc_adapter_info_adl == -1) return -1; // get a list (of ids of) valid/usable adapters @@ -2916,11 +2912,11 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) * save buffer required for later restores */ - hwmon_ctx->od_clock_mem_status = (ADLOD6MemClockState *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (ADLOD6MemClockState)); + hwmon_ctx->od_clock_mem_status = (ADLOD6MemClockState *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (ADLOD6MemClockState)); VERIFY_PTR (hwmon_ctx->od_clock_mem_status); - hwmon_ctx->od_power_control_status = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); + hwmon_ctx->od_power_control_status = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); VERIFY_PTR (hwmon_ctx->od_power_control_status); - hwmon_ctx->nvml_power_limit = (unsigned int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (unsigned int)); + hwmon_ctx->nvml_power_limit = (unsigned int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (unsigned int)); VERIFY_PTR (hwmon_ctx->nvml_power_limit); /** * HM devices: copy @@ -3071,7 +3067,7 @@ int hwmon_ctx_init (hashcat_ctx_t *hashcat_ctx) event_log_error (hashcat_ctx, "The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance"); } - ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) hccalloc (hashcat_ctx, 1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); + ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) hccalloc (hashcat_ctx, 1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); VERIFY_PTR (performance_state); performance_state->iNumberOfPerformanceLevels = 2; diff --git a/src/induct.c b/src/induct.c index b2abf03a6..441a71bf5 100644 --- a/src/induct.c +++ b/src/induct.c @@ -46,7 +46,7 @@ int induct_ctx_init (hashcat_ctx_t *hashcat_ctx) if (user_options->induction_dir == NULL) { - char *root_directory = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *root_directory = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (root_directory); snprintf (root_directory, HCBUFSIZ_TINY - 1, "%s/%s.%s", folder_config->session_dir, user_options->session, INDUCT_DIR); @@ -58,7 +58,7 @@ int induct_ctx_init (hashcat_ctx_t *hashcat_ctx) } else if (errno == ENOTEMPTY) { - char *root_directory_mv = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *root_directory_mv = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (root_directory_mv); snprintf (root_directory_mv, HCBUFSIZ_TINY - 1, "%s/%s.induct.%d", folder_config->session_dir, user_options->session, (int) status_ctx->proc_start); diff --git a/src/interface.c b/src/interface.c index 821fb245d..4638139d5 100644 --- a/src/interface.c +++ b/src/interface.c @@ -12934,7 +12934,7 @@ void to_hccap_t (hashcat_ctx_t *hashcat_ctx, hccap_t *hccap, const u32 salt_pos, } } -void ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos, const u32 digest_pos) +int ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos, const u32 digest_pos) { const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashes_t *hashes = hashcat_ctx->hashes; @@ -15039,9 +15039,9 @@ void ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos const u32 ckey_len = bitcoin_wallet->ckey_len; const u32 public_key_len = bitcoin_wallet->public_key_len; - char *cry_master_buf = (char *) hcmalloc (hashcat_ctx, (cry_master_len * 2) + 1); - char *ckey_buf = (char *) hcmalloc (hashcat_ctx, (ckey_len * 2) + 1); - char *public_key_buf = (char *) hcmalloc (hashcat_ctx, (public_key_len * 2) + 1); + char *cry_master_buf = (char *) hcmalloc (hashcat_ctx, (cry_master_len * 2) + 1); VERIFY_PTR (cry_master_buf); + char *ckey_buf = (char *) hcmalloc (hashcat_ctx, (ckey_len * 2) + 1); VERIFY_PTR (ckey_buf); + char *public_key_buf = (char *) hcmalloc (hashcat_ctx, (public_key_len * 2) + 1); VERIFY_PTR (public_key_buf); for (u32 i = 0, j = 0; i < cry_master_len; i += 1, j += 2) { @@ -15098,7 +15098,7 @@ void ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos const u32 data_len = seven_zip->data_len; - char *data_buf = (char *) hcmalloc (hashcat_ctx, (data_len * 2) + 1); + char *data_buf = (char *) hcmalloc (hashcat_ctx, (data_len * 2) + 1); VERIFY_PTR (data_buf); for (u32 i = 0, j = 0; i < data_len; i += 1, j += 2) { @@ -15919,6 +15919,8 @@ void ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const u32 salt_pos out_buf[pos + 1 + salt.salt_len] = 0; } + + return 0; } int hashconfig_init (hashcat_ctx_t *hashcat_ctx) diff --git a/src/logfile.c b/src/logfile.c index 05aff8bc6..cac3fc743 100644 --- a/src/logfile.c +++ b/src/logfile.c @@ -77,12 +77,12 @@ int logfile_init (hashcat_ctx_t *hashcat_ctx) if (user_options->logfile_disable == true) return 0; - logfile_ctx->logfile = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + logfile_ctx->logfile = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (logfile_ctx->logfile); snprintf (logfile_ctx->logfile, HCBUFSIZ_TINY - 1, "%s/%s.log", folder_config->session_dir, user_options->session); - logfile_ctx->subid = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); - logfile_ctx->topid = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + logfile_ctx->subid = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (logfile_ctx->subid); + logfile_ctx->topid = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (logfile_ctx->topid); logfile_ctx->enabled = true; diff --git a/src/loopback.c b/src/loopback.c index 7da270eee..f26d7ddbf 100644 --- a/src/loopback.c +++ b/src/loopback.c @@ -70,7 +70,7 @@ int loopback_init (hashcat_ctx_t *hashcat_ctx) loopback_ctx->enabled = true; loopback_ctx->fp = NULL; - loopback_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + loopback_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (loopback_ctx->filename); return 0; } diff --git a/src/main.c b/src/main.c index 7e1d40585..71c7ce498 100644 --- a/src/main.c +++ b/src/main.c @@ -119,7 +119,7 @@ static void main_outerloop_starting (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA hashcat_user->outer_threads_cnt = 0; - hashcat_user->outer_threads = (hc_thread_t *) hccalloc (hashcat_ctx, 2, sizeof (hc_thread_t)); + hashcat_user->outer_threads = (hc_thread_t *) hccalloc (hashcat_ctx, 2, sizeof (hc_thread_t)); if (hashcat_user->outer_threads == NULL) return; status_ctx->shutdown_outer = false; @@ -487,7 +487,7 @@ int main (int argc, char **argv) { // hashcat main context - hashcat_ctx_t *hashcat_ctx = (hashcat_ctx_t *) malloc (sizeof (hashcat_ctx_t)); + hashcat_ctx_t *hashcat_ctx = (hashcat_ctx_t *) malloc (sizeof (hashcat_ctx_t)); VERIFY_PTR (hashcat_ctx); const int rc_hashcat_init = hashcat_ctx_init (hashcat_ctx, event); @@ -513,7 +513,9 @@ int main (int argc, char **argv) // initialize the user options with some defaults (you can override them later) - user_options_init (hashcat_ctx); + const int rc_options_init = user_options_init (hashcat_ctx); + + if (rc_options_init == -1) return -1; // parse commandline parameters and check them @@ -558,7 +560,9 @@ int main (int argc, char **argv) // initialize the user options with some defaults (you can override them later) - user_options_init (hashcat_ctx); + const int rc_options_init = user_options_init (hashcat_ctx); + + if (rc_options_init == -1) return -1; // your own stuff diff --git a/src/memory.c b/src/memory.c index fd04c4ab7..a566914b2 100644 --- a/src/memory.c +++ b/src/memory.c @@ -16,7 +16,7 @@ void *hccalloc (hashcat_ctx_t *hashcat_ctx, const size_t nmemb, const size_t sz) { event_log_error (hashcat_ctx, "%s", MSG_ENOMEM); - exit (-1); + return (NULL); } return (p); @@ -30,7 +30,7 @@ void *hcmalloc (hashcat_ctx_t *hashcat_ctx, const size_t sz) { event_log_error (hashcat_ctx, "%s", MSG_ENOMEM); - exit (-1); + return (NULL); } memset (p, 0, sz); @@ -46,7 +46,7 @@ void *hcrealloc (hashcat_ctx_t *hashcat_ctx, void *ptr, const size_t oldsz, cons { event_log_error (hashcat_ctx, "%s", MSG_ENOMEM); - exit (-1); + return (NULL); } memset ((char *) p + oldsz, 0, addsz); @@ -60,7 +60,9 @@ char *hcstrdup (hashcat_ctx_t *hashcat_ctx, const char *s) char *b = (char *) hcmalloc (hashcat_ctx, len + 1); - strncpy (b, s, len); + if (b == NULL) return (NULL); + + memcpy (b, s, len); b[len] = 0; diff --git a/src/monitor.c b/src/monitor.c index 69e006daa..e7c7b8a5c 100644 --- a/src/monitor.c +++ b/src/monitor.c @@ -69,12 +69,12 @@ static int monitor (hashcat_ctx_t *hashcat_ctx) // these variables are mainly used for fan control - int *fan_speed_chgd = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); + int *fan_speed_chgd = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); VERIFY_PTR (fan_speed_chgd); // temperature controller "loopback" values - int *temp_diff_old = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); - int *temp_diff_sum = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); + int *temp_diff_old = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); VERIFY_PTR (temp_diff_old); + int *temp_diff_sum = (int *) hccalloc (hashcat_ctx, opencl_ctx->devices_cnt, sizeof (int)); VERIFY_PTR (temp_diff_sum); time_t last_temp_check_time; diff --git a/src/mpsp.c b/src/mpsp.c index 800fcfb5c..7bb31973f 100644 --- a/src/mpsp.c +++ b/src/mpsp.c @@ -114,7 +114,7 @@ static void mp_css_split_cnt (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_orig css_cnt_lr[1] = css_cnt_r; } -static void mp_css_append_salt (hashcat_ctx_t *hashcat_ctx, salt_t *salt_buf) +static int mp_css_append_salt (hashcat_ctx_t *hashcat_ctx, salt_t *salt_buf) { mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; @@ -123,7 +123,7 @@ static void mp_css_append_salt (hashcat_ctx_t *hashcat_ctx, salt_t *salt_buf) u32 css_cnt_salt = mask_ctx->css_cnt + salt_len; - cs_t *css_buf_salt = (cs_t *) hccalloc (hashcat_ctx, css_cnt_salt, sizeof (cs_t)); + cs_t *css_buf_salt = (cs_t *) hccalloc (hashcat_ctx, css_cnt_salt, sizeof (cs_t)); VERIFY_PTR (css_buf_salt); memcpy (css_buf_salt, mask_ctx->css_buf, mask_ctx->css_cnt * sizeof (cs_t)); @@ -137,15 +137,17 @@ static void mp_css_append_salt (hashcat_ctx_t *hashcat_ctx, salt_t *salt_buf) mask_ctx->css_buf = css_buf_salt; mask_ctx->css_cnt = css_cnt_salt; + + return 0; } -static void mp_css_unicode_expand (hashcat_ctx_t *hashcat_ctx) +static int mp_css_unicode_expand (hashcat_ctx_t *hashcat_ctx) { mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; u32 css_cnt_unicode = mask_ctx->css_cnt * 2; - cs_t *css_buf_unicode = (cs_t *) hccalloc (hashcat_ctx, css_cnt_unicode, sizeof (cs_t)); + cs_t *css_buf_unicode = (cs_t *) hccalloc (hashcat_ctx, css_cnt_unicode, sizeof (cs_t)); VERIFY_PTR (css_buf_unicode); for (u32 i = 0, j = 0; i < mask_ctx->css_cnt; i += 1, j += 2) { @@ -159,6 +161,8 @@ static void mp_css_unicode_expand (hashcat_ctx_t *hashcat_ctx) mask_ctx->css_buf = css_buf_unicode; mask_ctx->css_cnt = css_cnt_unicode; + + return 0; } static int mp_css_to_uniq_tbl (hashcat_ctx_t *hashcat_ctx, u32 css_cnt, cs_t *css, u32 uniq_tbls[SP_PW_MAX][CHARSIZ]) @@ -190,7 +194,7 @@ static int mp_css_to_uniq_tbl (hashcat_ctx_t *hashcat_ctx, u32 css_cnt, cs_t *cs return 0; } -static void mp_add_cs_buf (hashcat_ctx_t *hashcat_ctx, u32 *in_buf, size_t in_len, cs_t *css, u32 css_cnt) +static int mp_add_cs_buf (hashcat_ctx_t *hashcat_ctx, u32 *in_buf, size_t in_len, cs_t *css, u32 css_cnt) { const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; @@ -198,7 +202,7 @@ static void mp_add_cs_buf (hashcat_ctx_t *hashcat_ctx, u32 *in_buf, size_t in_le size_t css_uniq_sz = CHARSIZ * sizeof (u32); - u32 *css_uniq = (u32 *) hcmalloc (hashcat_ctx, css_uniq_sz); + u32 *css_uniq = (u32 *) hcmalloc (hashcat_ctx, css_uniq_sz); VERIFY_PTR (css_uniq); size_t i; @@ -225,6 +229,8 @@ static void mp_add_cs_buf (hashcat_ctx_t *hashcat_ctx, u32 *in_buf, size_t in_le } hcfree (css_uniq); + + return 0; } static int mp_expand (hashcat_ctx_t *hashcat_ctx, char *in_buf, size_t in_len, cs_t *mp_sys, cs_t *mp_usr, u32 mp_usr_offset, int interpret) @@ -245,37 +251,41 @@ static int mp_expand (hashcat_ctx_t *hashcat_ctx, char *in_buf, size_t in_len, c u32 p1 = in_buf[in_pos] & 0xff; + int rc = 0; + switch (p1) { - case 'l': mp_add_cs_buf (hashcat_ctx, mp_sys[0].cs_buf, mp_sys[0].cs_len, mp_usr, mp_usr_offset); + case 'l': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[0].cs_buf, mp_sys[0].cs_len, mp_usr, mp_usr_offset); break; - case 'u': mp_add_cs_buf (hashcat_ctx, mp_sys[1].cs_buf, mp_sys[1].cs_len, mp_usr, mp_usr_offset); + case 'u': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[1].cs_buf, mp_sys[1].cs_len, mp_usr, mp_usr_offset); break; - case 'd': mp_add_cs_buf (hashcat_ctx, mp_sys[2].cs_buf, mp_sys[2].cs_len, mp_usr, mp_usr_offset); + case 'd': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[2].cs_buf, mp_sys[2].cs_len, mp_usr, mp_usr_offset); break; - case 's': mp_add_cs_buf (hashcat_ctx, mp_sys[3].cs_buf, mp_sys[3].cs_len, mp_usr, mp_usr_offset); + case 's': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[3].cs_buf, mp_sys[3].cs_len, mp_usr, mp_usr_offset); break; - case 'a': mp_add_cs_buf (hashcat_ctx, mp_sys[4].cs_buf, mp_sys[4].cs_len, mp_usr, mp_usr_offset); + case 'a': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[4].cs_buf, mp_sys[4].cs_len, mp_usr, mp_usr_offset); break; - case 'b': mp_add_cs_buf (hashcat_ctx, mp_sys[5].cs_buf, mp_sys[5].cs_len, mp_usr, mp_usr_offset); + case 'b': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[5].cs_buf, mp_sys[5].cs_len, mp_usr, mp_usr_offset); break; case '1': if (mp_usr[0].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 1 is undefined"); return -1; } - mp_add_cs_buf (hashcat_ctx, mp_usr[0].cs_buf, mp_usr[0].cs_len, mp_usr, mp_usr_offset); + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[0].cs_buf, mp_usr[0].cs_len, mp_usr, mp_usr_offset); break; case '2': if (mp_usr[1].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 2 is undefined"); return -1; } - mp_add_cs_buf (hashcat_ctx, mp_usr[1].cs_buf, mp_usr[1].cs_len, mp_usr, mp_usr_offset); + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[1].cs_buf, mp_usr[1].cs_len, mp_usr, mp_usr_offset); break; case '3': if (mp_usr[2].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 3 is undefined"); return -1; } - mp_add_cs_buf (hashcat_ctx, mp_usr[2].cs_buf, mp_usr[2].cs_len, mp_usr, mp_usr_offset); + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[2].cs_buf, mp_usr[2].cs_len, mp_usr, mp_usr_offset); break; case '4': if (mp_usr[3].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 4 is undefined"); return -1; } - mp_add_cs_buf (hashcat_ctx, mp_usr[3].cs_buf, mp_usr[3].cs_len, mp_usr, mp_usr_offset); + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[3].cs_buf, mp_usr[3].cs_len, mp_usr, mp_usr_offset); break; - case '?': mp_add_cs_buf (hashcat_ctx, &p0, 1, mp_usr, mp_usr_offset); + case '?': rc = mp_add_cs_buf (hashcat_ctx, &p0, 1, mp_usr, mp_usr_offset); break; default: event_log_error (hashcat_ctx, "Syntax error: %s", in_buf); return -1; } + + if (rc == -1) return -1; } else { @@ -304,13 +314,17 @@ static int mp_expand (hashcat_ctx_t *hashcat_ctx, char *in_buf, size_t in_len, c chr = (u32) hex_convert ((u8) p1) << 0; chr |= (u32) hex_convert ((u8) p0) << 4; - mp_add_cs_buf (hashcat_ctx, &chr, 1, mp_usr, mp_usr_offset); + const int rc = mp_add_cs_buf (hashcat_ctx, &chr, 1, mp_usr, mp_usr_offset); + + if (rc == -1) return -1; } else { u32 chr = p0; - mp_add_cs_buf (hashcat_ctx, &chr, 1, mp_usr, mp_usr_offset); + const int rc = mp_add_cs_buf (hashcat_ctx, &chr, 1, mp_usr, mp_usr_offset); + + if (rc == -1) return -1; } } } @@ -318,12 +332,10 @@ static int mp_expand (hashcat_ctx_t *hashcat_ctx, char *in_buf, size_t in_len, c return 0; } -static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask_len, cs_t *mp_sys, cs_t *mp_usr, u32 *css_cnt) +static int mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask_len, cs_t *mp_sys, cs_t *mp_usr, cs_t *css_buf, u32 *css_cnt) { const user_options_t *user_options = hashcat_ctx->user_options; - cs_t *css = (cs_t *) hccalloc (hashcat_ctx, 256, sizeof (cs_t)); - u32 mask_pos; u32 css_pos; @@ -341,37 +353,41 @@ static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask u32 chr = (u32) p1; + int rc = 0; + switch (p1) { - case 'l': mp_add_cs_buf (hashcat_ctx, mp_sys[0].cs_buf, mp_sys[0].cs_len, css, css_pos); + case 'l': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[0].cs_buf, mp_sys[0].cs_len, css_buf, css_pos); break; - case 'u': mp_add_cs_buf (hashcat_ctx, mp_sys[1].cs_buf, mp_sys[1].cs_len, css, css_pos); + case 'u': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[1].cs_buf, mp_sys[1].cs_len, css_buf, css_pos); break; - case 'd': mp_add_cs_buf (hashcat_ctx, mp_sys[2].cs_buf, mp_sys[2].cs_len, css, css_pos); + case 'd': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[2].cs_buf, mp_sys[2].cs_len, css_buf, css_pos); break; - case 's': mp_add_cs_buf (hashcat_ctx, mp_sys[3].cs_buf, mp_sys[3].cs_len, css, css_pos); + case 's': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[3].cs_buf, mp_sys[3].cs_len, css_buf, css_pos); break; - case 'a': mp_add_cs_buf (hashcat_ctx, mp_sys[4].cs_buf, mp_sys[4].cs_len, css, css_pos); + case 'a': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[4].cs_buf, mp_sys[4].cs_len, css_buf, css_pos); break; - case 'b': mp_add_cs_buf (hashcat_ctx, mp_sys[5].cs_buf, mp_sys[5].cs_len, css, css_pos); + case 'b': rc = mp_add_cs_buf (hashcat_ctx, mp_sys[5].cs_buf, mp_sys[5].cs_len, css_buf, css_pos); break; - case '1': if (mp_usr[0].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 1 is undefined"); return NULL; } - mp_add_cs_buf (hashcat_ctx, mp_usr[0].cs_buf, mp_usr[0].cs_len, css, css_pos); + case '1': if (mp_usr[0].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 1 is undefined"); return -1; } + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[0].cs_buf, mp_usr[0].cs_len, css_buf, css_pos); break; - case '2': if (mp_usr[1].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 2 is undefined"); return NULL; } - mp_add_cs_buf (hashcat_ctx, mp_usr[1].cs_buf, mp_usr[1].cs_len, css, css_pos); + case '2': if (mp_usr[1].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 2 is undefined"); return -1; } + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[1].cs_buf, mp_usr[1].cs_len, css_buf, css_pos); break; - case '3': if (mp_usr[2].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 3 is undefined"); return NULL; } - mp_add_cs_buf (hashcat_ctx, mp_usr[2].cs_buf, mp_usr[2].cs_len, css, css_pos); + case '3': if (mp_usr[2].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 3 is undefined"); return -1; } + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[2].cs_buf, mp_usr[2].cs_len, css_buf, css_pos); break; - case '4': if (mp_usr[3].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 4 is undefined"); return NULL; } - mp_add_cs_buf (hashcat_ctx, mp_usr[3].cs_buf, mp_usr[3].cs_len, css, css_pos); + case '4': if (mp_usr[3].cs_len == 0) { event_log_error (hashcat_ctx, "Custom-charset 4 is undefined"); return -1; } + rc = mp_add_cs_buf (hashcat_ctx, mp_usr[3].cs_buf, mp_usr[3].cs_len, css_buf, css_pos); break; - case '?': mp_add_cs_buf (hashcat_ctx, &chr, 1, css, css_pos); + case '?': rc = mp_add_cs_buf (hashcat_ctx, &chr, 1, css_buf, css_pos); break; default: event_log_error (hashcat_ctx, "Syntax error: %s", mask_buf); - return NULL; + return -1; } + + if (rc == -1) return -1; } else { @@ -385,7 +401,7 @@ static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask { event_log_error (hashcat_ctx, "The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf); - return NULL; + return -1; } char p1 = mask_buf[mask_pos]; @@ -396,7 +412,7 @@ static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask { event_log_error (hashcat_ctx, "Invalid hex character detected in mask %s", mask_buf); - return NULL; + return -1; } u32 chr = 0; @@ -404,13 +420,17 @@ static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask chr |= (u32) hex_convert ((u8) p1) << 0; chr |= (u32) hex_convert ((u8) p0) << 4; - mp_add_cs_buf (hashcat_ctx, &chr, 1, css, css_pos); + const int rc = mp_add_cs_buf (hashcat_ctx, &chr, 1, css_buf, css_pos); + + if (rc == -1) return -1; } else { u32 chr = (u32) p0; - mp_add_cs_buf (hashcat_ctx, &chr, 1, css, css_pos); + const int rc = mp_add_cs_buf (hashcat_ctx, &chr, 1, css_buf, css_pos); + + if (rc == -1) return -1; } } } @@ -419,20 +439,18 @@ static cs_t *mp_gen_css (hashcat_ctx_t *hashcat_ctx, char *mask_buf, size_t mask { event_log_error (hashcat_ctx, "Invalid mask length (0)"); - return NULL; + return -1; } *css_cnt = css_pos; - return (css); + return 0; } -static char *mp_get_truncated_mask (hashcat_ctx_t *hashcat_ctx, const char *mask_buf, const size_t mask_len, const u32 len) +static int mp_get_truncated_mask (hashcat_ctx_t *hashcat_ctx, const char *mask_buf, const size_t mask_len, const u32 len, char *new_mask_buf) { const user_options_t *user_options = hashcat_ctx->user_options; - char *new_mask_buf = (char *) hcmalloc (hashcat_ctx, 256); - u32 mask_pos; u32 css_pos; @@ -463,7 +481,7 @@ static char *mp_get_truncated_mask (hashcat_ctx_t *hashcat_ctx, const char *mask { event_log_error (hashcat_ctx, "The hex-charset option always expects couples of exactly 2 hexadecimal chars, failed mask: %s", mask_buf); - return NULL; + return -1; } char p1 = mask_buf[mask_pos]; @@ -474,7 +492,7 @@ static char *mp_get_truncated_mask (hashcat_ctx_t *hashcat_ctx, const char *mask { event_log_error (hashcat_ctx, "Invalid hex character detected in mask: %s", mask_buf); - return NULL; + return -1; } new_mask_buf[mask_pos] = p1; @@ -482,11 +500,7 @@ static char *mp_get_truncated_mask (hashcat_ctx_t *hashcat_ctx, const char *mask } } - if (css_pos == len) return (new_mask_buf); - - hcfree (new_mask_buf); - - return (NULL); + return 0; } static void mp_setup_sys (cs_t *mp_sys) @@ -587,7 +601,7 @@ static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx) * Initialize hcstats */ - u64 *root_stats_buf = (u64 *) hccalloc (hashcat_ctx, SP_ROOT_CNT, sizeof (u64)); + u64 *root_stats_buf = (u64 *) hccalloc (hashcat_ctx, SP_ROOT_CNT, sizeof (u64)); VERIFY_PTR (root_stats_buf); u64 *root_stats_ptr = root_stats_buf; @@ -600,7 +614,7 @@ static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx) root_stats_ptr += CHARSIZ; } - u64 *markov_stats_buf = (u64 *) hccalloc (hashcat_ctx, SP_MARKOV_CNT, sizeof (u64)); + u64 *markov_stats_buf = (u64 *) hccalloc (hashcat_ctx, SP_MARKOV_CNT, sizeof (u64)); VERIFY_PTR (markov_stats_buf); u64 *markov_stats_ptr = markov_stats_buf; @@ -886,13 +900,13 @@ void sp_exec (u64 ctx, char *pw_buf, cs_t *root_css_buf, cs_t *markov_css_buf, u } } -static void mask_append_final (hashcat_ctx_t *hashcat_ctx, const char *mask) +static int mask_append_final (hashcat_ctx_t *hashcat_ctx, const char *mask) { mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; if (mask_ctx->masks_avail == mask_ctx->masks_cnt) { - mask_ctx->masks = (char **) hcrealloc (hashcat_ctx, mask_ctx->masks, mask_ctx->masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *)); + mask_ctx->masks = (char **) hcrealloc (hashcat_ctx, mask_ctx->masks, mask_ctx->masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *)); VERIFY_PTR (mask_ctx->masks); mask_ctx->masks_avail += INCR_MASKS; } @@ -900,9 +914,11 @@ static void mask_append_final (hashcat_ctx_t *hashcat_ctx, const char *mask) mask_ctx->masks[mask_ctx->masks_cnt] = hcstrdup (hashcat_ctx, mask); mask_ctx->masks_cnt++; + + return 0; } -static void mask_append (hashcat_ctx_t *hashcat_ctx, const char *mask) +static int mask_append (hashcat_ctx_t *hashcat_ctx, const char *mask) { user_options_t *user_options = hashcat_ctx->user_options; @@ -910,17 +926,25 @@ static void mask_append (hashcat_ctx_t *hashcat_ctx, const char *mask) { for (u32 increment_len = user_options->increment_min; increment_len <= user_options->increment_max; increment_len++) { - char *mask_truncated = mp_get_truncated_mask (hashcat_ctx, mask, strlen (mask), increment_len); + char *mask_truncated = (char *) hcmalloc (hashcat_ctx, 256); VERIFY_PTR (mask_truncated); - if (mask_truncated == NULL) break; + const int rc_truncated_mask = mp_get_truncated_mask (hashcat_ctx, mask, strlen (mask), increment_len, mask_truncated); - mask_append_final (hashcat_ctx, mask_truncated); + if (rc_truncated_mask == -1) break; + + const int rc = mask_append_final (hashcat_ctx, mask_truncated); + + if (rc == -1) return -1; } } else { - mask_append_final (hashcat_ctx, mask); + const int rc = mask_append_final (hashcat_ctx, mask); + + if (rc == -1) return -1; } + + return 0; } int mask_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) @@ -948,9 +972,11 @@ int mask_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) if (rc_mask_file == -1) return -1; - mask_ctx->css_buf = mp_gen_css (hashcat_ctx, mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt); + mask_ctx->css_buf = (cs_t *) hccalloc (hashcat_ctx, 256, sizeof (cs_t)); VERIFY_PTR (mask_ctx->css_buf); - if (mask_ctx->css_buf == NULL) return -1; + const int rc_gen_css = mp_gen_css (hashcat_ctx, mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, mask_ctx->css_buf, &mask_ctx->css_cnt); + + if (rc_gen_css == -1) return -1; u32 uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } }; @@ -979,9 +1005,11 @@ int mask_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) if (user_options->attack_mode == ATTACK_MODE_BF) // always true { - mask_ctx->css_buf = mp_gen_css (hashcat_ctx, mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt); + mask_ctx->css_buf = (cs_t *) hccalloc (hashcat_ctx, 256, sizeof (cs_t)); VERIFY_PTR (mask_ctx->css_buf); - if (mask_ctx->css_buf == NULL) return -1; + const int rc_gen_css = mp_gen_css (hashcat_ctx, mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, mask_ctx->css_buf, &mask_ctx->css_cnt); + + if (rc_gen_css == -1) return -1; // special case for benchmark @@ -1029,7 +1057,9 @@ int mask_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) { - mp_css_unicode_expand (hashcat_ctx); + const int rc = mp_css_unicode_expand (hashcat_ctx); + + if (rc == -1) return -1; } u32 css_cnt_orig = mask_ctx->css_cnt; @@ -1038,7 +1068,9 @@ int mask_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) { if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT) { - mp_css_append_salt (hashcat_ctx, &hashes->salts_buf[0]); + const int rc = mp_css_append_salt (hashcat_ctx, &hashes->salts_buf[0]); + + if (rc == -1) return -1; } } @@ -1086,13 +1118,13 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) mask_ctx->enabled = true; - mask_ctx->root_table_buf = (hcstat_table_t *) hccalloc (hashcat_ctx, SP_ROOT_CNT, sizeof (hcstat_table_t)); - mask_ctx->markov_table_buf = (hcstat_table_t *) hccalloc (hashcat_ctx, SP_MARKOV_CNT, sizeof (hcstat_table_t)); + mask_ctx->root_table_buf = (hcstat_table_t *) hccalloc (hashcat_ctx, SP_ROOT_CNT, sizeof (hcstat_table_t)); VERIFY_PTR (mask_ctx->root_table_buf); + mask_ctx->markov_table_buf = (hcstat_table_t *) hccalloc (hashcat_ctx, SP_MARKOV_CNT, sizeof (hcstat_table_t)); VERIFY_PTR (mask_ctx->markov_table_buf); sp_setup_tbl (hashcat_ctx); - mask_ctx->root_css_buf = (cs_t *) hccalloc (hashcat_ctx, SP_PW_MAX, sizeof (cs_t)); - mask_ctx->markov_css_buf = (cs_t *) hccalloc (hashcat_ctx, SP_PW_MAX * CHARSIZ, sizeof (cs_t)); + mask_ctx->root_css_buf = (cs_t *) hccalloc (hashcat_ctx, SP_PW_MAX, sizeof (cs_t)); VERIFY_PTR (mask_ctx->root_css_buf); + mask_ctx->markov_css_buf = (cs_t *) hccalloc (hashcat_ctx, SP_PW_MAX * CHARSIZ, sizeof (cs_t)); VERIFY_PTR (mask_ctx->markov_css_buf); mask_ctx->css_cnt = 0; mask_ctx->css_buf = NULL; @@ -1103,7 +1135,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) mask_ctx->masks_pos = 0; mask_ctx->masks_cnt = 0; - mask_ctx->mfs = (mf_t *) hccalloc (hashcat_ctx, MAX_MFS, sizeof (mf_t)); + mask_ctx->mfs = (mf_t *) hccalloc (hashcat_ctx, MAX_MFS, sizeof (mf_t)); VERIFY_PTR (mask_ctx->mfs); mp_setup_sys (mask_ctx->mp_sys); @@ -1124,7 +1156,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (stat (arg, &file_stat) == -1) { - mask_append (hashcat_ctx, arg); + const int rc = mask_append (hashcat_ctx, arg); + + if (rc == -1) return -1; } else { @@ -1152,7 +1186,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) return -1; } - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (mask_fp)) { @@ -1162,7 +1196,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (line_buf[0] == '#') continue; - mask_append (hashcat_ctx, line_buf); + const int rc = mask_append (hashcat_ctx, line_buf); + + if (rc == -1) return -1; } hcfree (line_buf); @@ -1182,14 +1218,18 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) { const char *mask = DEF_MASK; - mask_append (hashcat_ctx, mask); + const int rc = mask_append (hashcat_ctx, mask); + + if (rc == -1) return -1; } } else { const char *mask = hashconfig_benchmark_mask (hashcat_ctx); - mask_append (hashcat_ctx, mask); + const int rc = mask_append (hashcat_ctx, mask); + + if (rc == -1) return -1; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) @@ -1204,7 +1244,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (stat (arg, &file_stat) == -1) { - mask_append (hashcat_ctx, arg); + const int rc = mask_append (hashcat_ctx, arg); + + if (rc == -1) return -1; } else { @@ -1221,7 +1263,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) return -1; } - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (mask_fp)) { @@ -1231,7 +1273,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (line_buf[0] == '#') continue; - mask_append (hashcat_ctx, line_buf); + const int rc = mask_append (hashcat_ctx, line_buf); + + if (rc == -1) return -1; } hcfree (line_buf); @@ -1258,7 +1302,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (stat (arg, &file_stat) == -1) { - mask_append (hashcat_ctx, arg); + const int rc = mask_append (hashcat_ctx, arg); + + if (rc == -1) return -1; } else { @@ -1275,7 +1321,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) return -1; } - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (mask_fp)) { @@ -1285,7 +1331,9 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) if (line_buf[0] == '#') continue; - mask_append (hashcat_ctx, line_buf); + const int rc = mask_append (hashcat_ctx, line_buf); + + if (rc == -1) return -1; } hcfree (line_buf); diff --git a/src/opencl.c b/src/opencl.c index 5243a9bfd..434f258e2 100644 --- a/src/opencl.c +++ b/src/opencl.c @@ -224,7 +224,7 @@ static int read_kernel_binary (hashcat_ctx_t *hashcat_ctx, const char *kernel_fi stat (kernel_file, &st); - char *buf = (char *) hcmalloc (hashcat_ctx, st.st_size + 1); + char *buf = (char *) hcmalloc (hashcat_ctx, st.st_size + 1); VERIFY_PTR (buf); size_t num_read = fread (buf, sizeof (char), st.st_size, fp); @@ -1891,7 +1891,7 @@ int opencl_ctx_init (hashcat_ctx_t *hashcat_ctx) if (user_options->usage == true) return 0; if (user_options->version == true) return 0; - hc_device_param_t *devices_param = (hc_device_param_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hc_device_param_t)); + hc_device_param_t *devices_param = (hc_device_param_t *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (hc_device_param_t)); VERIFY_PTR (devices_param); opencl_ctx->devices_param = devices_param; @@ -1899,7 +1899,7 @@ int opencl_ctx_init (hashcat_ctx_t *hashcat_ctx) * Load and map OpenCL library calls */ - OCL_PTR *ocl = (OCL_PTR *) hcmalloc (hashcat_ctx, sizeof (OCL_PTR)); + OCL_PTR *ocl = (OCL_PTR *) hcmalloc (hashcat_ctx, sizeof (OCL_PTR)); VERIFY_PTR (ocl); opencl_ctx->ocl = ocl; @@ -1948,9 +1948,9 @@ int opencl_ctx_init (hashcat_ctx_t *hashcat_ctx) */ cl_uint platforms_cnt = 0; - cl_platform_id *platforms = (cl_platform_id *) hccalloc (hashcat_ctx, CL_PLATFORMS_MAX, sizeof (cl_platform_id)); + cl_platform_id *platforms = (cl_platform_id *) hccalloc (hashcat_ctx, CL_PLATFORMS_MAX, sizeof (cl_platform_id)); VERIFY_PTR (platforms); cl_uint platform_devices_cnt = 0; - cl_device_id *platform_devices = (cl_device_id *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (cl_device_id)); + cl_device_id *platform_devices = (cl_device_id *) hccalloc (hashcat_ctx, DEVICES_MAX, sizeof (cl_device_id)); VERIFY_PTR (platform_devices); cl_int CL_err = hc_clGetPlatformIDs (hashcat_ctx, CL_PLATFORMS_MAX, platforms, &platforms_cnt); @@ -2245,7 +2245,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *device_name = (char *) hcmalloc (hashcat_ctx, param_value_size); + char *device_name = (char *) hcmalloc (hashcat_ctx, param_value_size); VERIFY_PTR (device_name); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL); @@ -2259,7 +2259,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *device_vendor = (char *) hcmalloc (hashcat_ctx, param_value_size); + char *device_vendor = (char *) hcmalloc (hashcat_ctx, param_value_size); VERIFY_PTR (device_vendor); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL); @@ -2314,7 +2314,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *device_version = (char *) hcmalloc (hashcat_ctx, param_value_size); + char *device_version = (char *) hcmalloc (hashcat_ctx, param_value_size); VERIFY_PTR (device_version); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL); @@ -2328,7 +2328,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *device_opencl_version = (char *) hcmalloc (hashcat_ctx, param_value_size); + char *device_opencl_version = (char *) hcmalloc (hashcat_ctx, param_value_size); VERIFY_PTR (device_opencl_version); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL); @@ -2455,7 +2455,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *device_extensions = hcmalloc (hashcat_ctx, device_extensions_size + 1); + char *device_extensions = hcmalloc (hashcat_ctx, device_extensions_size + 1); VERIFY_PTR (device_extensions); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL); @@ -2523,7 +2523,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) if (CL_err == -1) return -1; - char *driver_version = (char *) hcmalloc (hashcat_ctx, param_value_size); + char *driver_version = (char *) hcmalloc (hashcat_ctx, param_value_size); VERIFY_PTR (driver_version); CL_err = hc_clGetDeviceInfo (hashcat_ctx, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL); @@ -2533,7 +2533,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime) // device_name_chksum - char *device_name_chksum = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *device_name_chksum = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (device_name_chksum); #if defined (__x86_64__) snprintf (device_name_chksum, HCBUFSIZ_TINY - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, comptime); @@ -3499,9 +3499,9 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) * kernel compile or load */ - size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); + size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); VERIFY_PTR (kernel_lengths); - char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); + char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); VERIFY_PTR (kernel_sources); if (opencl_ctx->force_jit_compilation == -1) { @@ -3533,7 +3533,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err != CL_SUCCESS) #endif { - char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); + char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); VERIFY_PTR (build_log); CL_err = hc_clGetProgramBuildInfo (hashcat_ctx, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL); @@ -3559,7 +3559,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err == -1) return -1; - char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); + char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); VERIFY_PTR (binary); CL_err = hc_clGetProgramInfo (hashcat_ctx, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL); @@ -3635,7 +3635,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err != CL_SUCCESS) #endif { - char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); + char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); VERIFY_PTR (build_log); CL_err = hc_clGetProgramBuildInfo (hashcat_ctx, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL); @@ -3703,9 +3703,9 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) * kernel compile or load */ - size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); + size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); VERIFY_PTR (kernel_lengths); - char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); + char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); VERIFY_PTR (kernel_sources); if (cached == 0) { @@ -3736,7 +3736,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err != CL_SUCCESS) #endif { - char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); + char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); VERIFY_PTR (build_log); CL_err = hc_clGetProgramBuildInfo (hashcat_ctx, device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL); @@ -3762,7 +3762,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err == -1) return -1; - char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); + char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); VERIFY_PTR (binary); CL_err = hc_clGetProgramInfo (hashcat_ctx, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL); @@ -3844,9 +3844,9 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) * kernel compile or load */ - size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); + size_t *kernel_lengths = (size_t *) hcmalloc (hashcat_ctx, sizeof (size_t)); VERIFY_PTR (kernel_lengths); - char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); + char **kernel_sources = (char **) hcmalloc (hashcat_ctx, sizeof (char *)); VERIFY_PTR (kernel_sources); if (cached == 0) { @@ -3877,7 +3877,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err != CL_SUCCESS) #endif { - char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); + char *build_log = (char *) hcmalloc (hashcat_ctx, build_log_size + 1); VERIFY_PTR (build_log); CL_err = hc_clGetProgramBuildInfo (hashcat_ctx, device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL); @@ -3903,7 +3903,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) if (CL_err == -1) return -1; - char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); + char *binary = (char *) hcmalloc (hashcat_ctx, binary_size); VERIFY_PTR (binary); CL_err = hc_clGetProgramInfo (hashcat_ctx, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL); @@ -4048,15 +4048,15 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) * main host data */ - pw_t *pws_buf = (pw_t *) hcmalloc (hashcat_ctx, size_pws); + pw_t *pws_buf = (pw_t *) hcmalloc (hashcat_ctx, size_pws); VERIFY_PTR (pws_buf); device_param->pws_buf = pws_buf; - comb_t *combs_buf = (comb_t *) hccalloc (hashcat_ctx, KERNEL_COMBS, sizeof (comb_t)); + comb_t *combs_buf = (comb_t *) hccalloc (hashcat_ctx, KERNEL_COMBS, sizeof (comb_t)); VERIFY_PTR (combs_buf); device_param->combs_buf = combs_buf; - void *hooks_buf = hcmalloc (hashcat_ctx, size_hooks); + void *hooks_buf = hcmalloc (hashcat_ctx, size_hooks); VERIFY_PTR (hooks_buf); device_param->hooks_buf = hooks_buf; diff --git a/src/outfile_check.c b/src/outfile_check.c index d4abf49a0..f86241979 100644 --- a/src/outfile_check.c +++ b/src/outfile_check.c @@ -16,7 +16,7 @@ #include "shared.h" #include "thread.h" -static void outfile_remove (hashcat_ctx_t *hashcat_ctx) +static int outfile_remove (hashcat_ctx_t *hashcat_ctx) { // some hash-dependent constants @@ -38,10 +38,10 @@ static void outfile_remove (hashcat_ctx_t *hashcat_ctx) // buffers hash_t hash_buf = { 0, 0, 0, 0, 0 }; - hash_buf.digest = hcmalloc (hashcat_ctx, dgst_size); + hash_buf.digest = hcmalloc (hashcat_ctx, dgst_size); VERIFY_PTR (hash_buf.digest); - if (is_salted) hash_buf.salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); - if (esalt_size) hash_buf.esalt = (void *) hcmalloc (hashcat_ctx, esalt_size); + if (is_salted) hash_buf.salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); VERIFY_PTR (hash_buf.salt); + if (esalt_size) hash_buf.esalt = (void *) hcmalloc (hashcat_ctx, esalt_size); VERIFY_PTR (hash_buf.esalt); u32 digest_buf[64] = { 0 }; @@ -83,7 +83,7 @@ static void outfile_remove (hashcat_ctx_t *hashcat_ctx) if (out_cnt_new > 0) { - out_info_new = (outfile_data_t *) hccalloc (hashcat_ctx, out_cnt_new, sizeof (outfile_data_t)); + out_info_new = (outfile_data_t *) hccalloc (hashcat_ctx, out_cnt_new, sizeof (outfile_data_t)); VERIFY_PTR (out_info_new); for (int i = 0; i < out_cnt_new; i++) { @@ -146,7 +146,7 @@ static void outfile_remove (hashcat_ctx_t *hashcat_ctx) fseek (fp, out_info[j].seek, SEEK_SET); - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); while (!feof (fp)) { @@ -307,13 +307,17 @@ static void outfile_remove (hashcat_ctx_t *hashcat_ctx) hcfree (out_info); hcfree (out_files); + + return 0; } void *thread_outfile_remove (void *p) { hashcat_ctx_t *hashcat_ctx = (hashcat_ctx_t *) p; - outfile_remove (hashcat_ctx); + const int rc = outfile_remove (hashcat_ctx); + + if (rc == -1) return NULL; return NULL; } @@ -339,7 +343,7 @@ int outcheck_ctx_init (hashcat_ctx_t *hashcat_ctx) if (user_options->outfile_check_dir == NULL) { - outcheck_ctx->root_directory = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + outcheck_ctx->root_directory = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (outcheck_ctx->root_directory); snprintf (outcheck_ctx->root_directory, HCBUFSIZ_TINY - 1, "%s/%s.%s", folder_config->session_dir, user_options->session, OUTFILES_DIR); } diff --git a/src/potfile.c b/src/potfile.c index ea2fee650..9fd1b9923 100644 --- a/src/potfile.c +++ b/src/potfile.c @@ -164,14 +164,14 @@ int potfile_init (hashcat_ctx_t *hashcat_ctx) if (user_options->potfile_path == NULL) { - potfile_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + potfile_ctx->filename = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (potfile_ctx->filename); potfile_ctx->fp = NULL; snprintf (potfile_ctx->filename, HCBUFSIZ_TINY - 1, "%s/hashcat.potfile", folder_config->profile_dir); } else { - potfile_ctx->filename = hcstrdup (hashcat_ctx, user_options->potfile_path); + potfile_ctx->filename = hcstrdup (hashcat_ctx, user_options->potfile_path); VERIFY_PTR (potfile_ctx->filename); potfile_ctx->fp = NULL; } @@ -216,22 +216,22 @@ int potfile_read_open (hashcat_ctx_t *hashcat_ctx) return 0; } -void potfile_read_parse (hashcat_ctx_t *hashcat_ctx) +int potfile_read_parse (hashcat_ctx_t *hashcat_ctx) { potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; hashconfig_t *hashconfig = hashcat_ctx->hashconfig; - if (potfile_ctx->enabled == false) return; + if (potfile_ctx->enabled == false) return 0; - if (potfile_ctx->fp == NULL) return; + if (potfile_ctx->fp == NULL) return 0; potfile_ctx->pot_avail = count_lines (hashcat_ctx, potfile_ctx->fp); - potfile_ctx->pot = (pot_t *) hccalloc (hashcat_ctx, potfile_ctx->pot_avail, sizeof (pot_t)); + potfile_ctx->pot = (pot_t *) hccalloc (hashcat_ctx, potfile_ctx->pot_avail, sizeof (pot_t)); VERIFY_PTR (potfile_ctx->pot); rewind (potfile_ctx->fp); - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); for (u32 line_num = 0; line_num < potfile_ctx->pot_avail; line_num++) { @@ -246,7 +246,9 @@ void potfile_read_parse (hashcat_ctx_t *hashcat_ctx) if (potfile_ctx->pot_cnt == potfile_ctx->pot_hashes_avail) { - potfile_hash_alloc (hashcat_ctx, INCR_POT); + const int rc = potfile_hash_alloc (hashcat_ctx, INCR_POT); + + if (rc == -1) return -1; } int parser_status; @@ -324,6 +326,8 @@ void potfile_read_parse (hashcat_ctx_t *hashcat_ctx) hcfree (line_buf); hc_qsort_r (potfile_ctx->pot, potfile_ctx->pot_cnt, sizeof (pot_t), sort_by_pot, (void *) hashconfig); + + return 0; } void potfile_read_close (hashcat_ctx_t *hashcat_ctx) @@ -418,12 +422,12 @@ void potfile_write_append (hashcat_ctx_t *hashcat_ctx, const char *out_buf, u8 * fflush (potfile_ctx->fp); } -void potfile_hash_alloc (hashcat_ctx_t *hashcat_ctx, const u32 num) +int potfile_hash_alloc (hashcat_ctx_t *hashcat_ctx, const u32 num) { potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; hashconfig_t *hashconfig = hashcat_ctx->hashconfig; - if (potfile_ctx->enabled == false) return; + if (potfile_ctx->enabled == false) return 0; u32 pos = 0; @@ -435,20 +439,22 @@ void potfile_hash_alloc (hashcat_ctx_t *hashcat_ctx, const u32 num) hash_t *tmp_hash = &tmp_pot->hash; - tmp_hash->digest = hcmalloc (hashcat_ctx, hashconfig->dgst_size); + tmp_hash->digest = hcmalloc (hashcat_ctx, hashconfig->dgst_size); VERIFY_PTR (tmp_hash->digest); if (hashconfig->is_salted) { - tmp_hash->salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); + tmp_hash->salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); VERIFY_PTR (tmp_hash->salt); } if (hashconfig->esalt_size) { - tmp_hash->esalt = hcmalloc (hashcat_ctx, hashconfig->esalt_size); + tmp_hash->esalt = hcmalloc (hashcat_ctx, hashconfig->esalt_size); VERIFY_PTR (tmp_hash->esalt); } potfile_ctx->pot_hashes_avail++; } + + return 0; } void potfile_hash_free (hashcat_ctx_t *hashcat_ctx) @@ -553,12 +559,12 @@ void potfile_left_request (hashcat_ctx_t *hashcat_ctx, char *input_buf, int inpu } } -void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)) +int potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; - if (potfile_ctx->enabled == false) return; + if (potfile_ctx->enabled == false) return 0; // left @@ -588,11 +594,12 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i { weak_hash_found = 1; - pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); + pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); VERIFY_PTR (pot_right_ptr); // in theory this is not needed, but we are paranoia: memset (pot_right_ptr->plain_buf, 0, sizeof (pot_right_ptr->plain_buf)); + pot_right_ptr->plain_len = 0; } } @@ -601,7 +608,7 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i { if (weak_hash_found == 1) hcfree (pot_right_ptr); // this shouldn't happen at all: if weak_hash_found == 1, than pot_right_ptr is not NULL for sure - return; + return 0; } // at least one half was found: @@ -613,6 +620,7 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i // user unsigned char *username = NULL; + u32 user_len = 0; if (hash_left->hash_info) @@ -638,11 +646,12 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i { left_part_masked = 1; - pot_left_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); + pot_left_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); VERIFY_PTR (pot_left_ptr); memset (pot_left_ptr->plain_buf, 0, sizeof (pot_left_ptr->plain_buf)); memcpy (pot_left_ptr->plain_buf, LM_MASKED_PLAIN, mask_plain_len); + pot_left_ptr->plain_len = mask_plain_len; } @@ -650,11 +659,12 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i { right_part_masked = 1; - pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); + pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); VERIFY_PTR (pot_right_ptr); memset (pot_right_ptr->plain_buf, 0, sizeof (pot_right_ptr->plain_buf)); memcpy (pot_right_ptr->plain_buf, LM_MASKED_PLAIN, mask_plain_len); + pot_right_ptr->plain_len = mask_plain_len; } @@ -680,14 +690,16 @@ void potfile_show_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i if (left_part_masked == 1) hcfree (pot_left_ptr); if (right_part_masked == 1) hcfree (pot_right_ptr); + + return 0; } -void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)) +int potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int input_len, hash_t *hash_left, hash_t *hash_right, int (*sort_by_pot) (const void *, const void *, void *)) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; - if (potfile_ctx->enabled == false) return; + if (potfile_ctx->enabled == false) return 0; // left @@ -717,7 +729,7 @@ void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i // we just need that pot_right_ptr is not a NULL pointer - pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); + pot_right_ptr = (pot_t *) hccalloc (hashcat_ctx, 1, sizeof (pot_t)); VERIFY_PTR (pot_right_ptr); } } @@ -725,7 +737,7 @@ void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i { if (weak_hash_found == 1) hcfree (pot_right_ptr); - return; + return 0; } // ... at least one part was not cracked @@ -738,7 +750,7 @@ void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i u32 user_len = (u32)input_len - 32u; - char *hash_output = (char *) hcmalloc (hashcat_ctx, 33); + char *hash_output = (char *) hcmalloc (hashcat_ctx, 33); VERIFY_PTR (hash_output); memcpy (hash_output, input_buf, input_len); @@ -769,31 +781,33 @@ void potfile_left_request_lm (hashcat_ctx_t *hashcat_ctx, char *input_buf, int i hcfree (hash_output); if (weak_hash_found == 1) hcfree (pot_right_ptr); + + return 0; } -void potfile_remove_parse (hashcat_ctx_t *hashcat_ctx) +int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashes_t *hashes = hashcat_ctx->hashes; potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; - if (potfile_ctx->enabled == false) return; + if (potfile_ctx->enabled == false) return 0; hash_t *hashes_buf = hashes->hashes_buf; u32 hashes_cnt = hashes->hashes_cnt; // no solution for these special hash types (for instane because they use hashfile in output etc) - if (hashconfig->hash_mode == 5200) return; + if (hashconfig->hash_mode == 5200) return 0; if ((hashconfig->hash_mode >= 6200) - && (hashconfig->hash_mode <= 6299)) return; - if (hashconfig->hash_mode == 9000) return; + && (hashconfig->hash_mode <= 6299)) return 0; + if (hashconfig->hash_mode == 9000) return 0; if ((hashconfig->hash_mode >= 13700) - && (hashconfig->hash_mode <= 13799)) return; + && (hashconfig->hash_mode <= 13799)) return 0; hash_t hash_buf; - hash_buf.digest = hcmalloc (hashcat_ctx, hashconfig->dgst_size); + hash_buf.digest = hcmalloc (hashcat_ctx, hashconfig->dgst_size); VERIFY_PTR (hash_buf.digest); hash_buf.salt = NULL; hash_buf.esalt = NULL; hash_buf.hash_info = NULL; @@ -801,25 +815,25 @@ void potfile_remove_parse (hashcat_ctx_t *hashcat_ctx) if (hashconfig->is_salted) { - hash_buf.salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); + hash_buf.salt = (salt_t *) hcmalloc (hashcat_ctx, sizeof (salt_t)); VERIFY_PTR (hash_buf.salt); } if (hashconfig->esalt_size) { - hash_buf.esalt = hcmalloc (hashcat_ctx, hashconfig->esalt_size); + hash_buf.esalt = hcmalloc (hashcat_ctx, hashconfig->esalt_size); VERIFY_PTR (hash_buf.esalt); } const int rc = potfile_read_open (hashcat_ctx); - if (rc == -1) return; + if (rc == -1) return -1; - char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf); // to be safe work with a copy (because of line_len loop, i etc) // moved up here because it's easier to handle continue case // it's just 64kb - char *line_buf_cpy = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *line_buf_cpy = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (line_buf_cpy); while (!feof (potfile_ctx->fp)) { @@ -973,4 +987,6 @@ void potfile_remove_parse (hashcat_ctx_t *hashcat_ctx) } hcfree (hash_buf.digest); + + return 0; } diff --git a/src/restore.c b/src/restore.c index be40db0b1..f5513cbc6 100644 --- a/src/restore.c +++ b/src/restore.c @@ -62,7 +62,7 @@ static int check_running_process (hashcat_ctx_t *hashcat_ctx) if (fp == NULL) return 0; - restore_data_t *rd = (restore_data_t *) hcmalloc (hashcat_ctx, sizeof (restore_data_t)); + restore_data_t *rd = (restore_data_t *) hcmalloc (hashcat_ctx, sizeof (restore_data_t)); VERIFY_PTR (rd); const size_t nread = fread (rd, sizeof (restore_data_t), 1, fp); @@ -77,7 +77,7 @@ static int check_running_process (hashcat_ctx_t *hashcat_ctx) if (rd->pid) { - char *pidbin = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *pidbin = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (pidbin); int pidbin_len = -1; @@ -113,7 +113,7 @@ static int check_running_process (hashcat_ctx_t *hashcat_ctx) #elif defined (_WIN) HANDLE hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, rd->pid); - char *pidbin2 = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *pidbin2 = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (pidbin2); int pidbin2_len = -1; @@ -156,7 +156,7 @@ static int init_restore (hashcat_ctx_t *hashcat_ctx) { restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx; - restore_data_t *rd = (restore_data_t *) hcmalloc (hashcat_ctx, sizeof (restore_data_t)); + restore_data_t *rd = (restore_data_t *) hcmalloc (hashcat_ctx, sizeof (restore_data_t)); VERIFY_PTR (rd); restore_ctx->rd = rd; @@ -211,9 +211,9 @@ static int read_restore (hashcat_ctx_t *hashcat_ctx) return -1; } - rd->argv = (char **) hccalloc (hashcat_ctx, rd->argc, sizeof (char *)); + rd->argv = (char **) hccalloc (hashcat_ctx, rd->argc, sizeof (char *)); VERIFY_PTR (rd->argv); - char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (buf); for (u32 i = 0; i < rd->argc; i++) { @@ -395,8 +395,8 @@ int restore_ctx_init (hashcat_ctx_t *hashcat_ctx, int argc, char **argv) restore_ctx->enabled = false; - char *eff_restore_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); - char *new_restore_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *eff_restore_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (eff_restore_file); + char *new_restore_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (new_restore_file); snprintf (eff_restore_file, HCBUFSIZ_TINY - 1, "%s/%s.restore", folder_config->session_dir, user_options->session); snprintf (new_restore_file, HCBUFSIZ_TINY - 1, "%s/%s.restore.new", folder_config->session_dir, user_options->session); diff --git a/src/rp.c b/src/rp.c index b9b84a199..9049fcd84 100644 --- a/src/rp.c +++ b/src/rp.c @@ -728,12 +728,12 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32 if (user_options->rp_files_cnt) { - all_kernel_rules_cnt = (u32 *) hccalloc (hashcat_ctx, user_options->rp_files_cnt, sizeof (u32)); + all_kernel_rules_cnt = (u32 *) hccalloc (hashcat_ctx, user_options->rp_files_cnt, sizeof (u32)); VERIFY_PTR (all_kernel_rules_cnt); - all_kernel_rules_buf = (kernel_rule_t **) hccalloc (hashcat_ctx, user_options->rp_files_cnt, sizeof (kernel_rule_t *)); + all_kernel_rules_buf = (kernel_rule_t **) hccalloc (hashcat_ctx, user_options->rp_files_cnt, sizeof (kernel_rule_t *)); VERIFY_PTR (all_kernel_rules_buf); } - char *rule_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *rule_buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (rule_buf); int rule_len = 0; @@ -773,7 +773,7 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32 if (kernel_rules_avail == kernel_rules_cnt) { - kernel_rules_buf = (kernel_rule_t *) hcrealloc (hashcat_ctx, kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t)); + kernel_rules_buf = (kernel_rule_t *) hcrealloc (hashcat_ctx, kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t)); VERIFY_PTR (kernel_rules_buf); kernel_rules_avail += INCR_RULES; } @@ -816,7 +816,7 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32 u32 kernel_rules_cnt = 1; - u32 *repeats = (u32 *) hccalloc (hashcat_ctx, user_options->rp_files_cnt + 1, sizeof (u32)); + u32 *repeats = (u32 *) hccalloc (hashcat_ctx, user_options->rp_files_cnt + 1, sizeof (u32)); VERIFY_PTR (repeats); repeats[0] = kernel_rules_cnt; @@ -827,7 +827,7 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32 repeats[i + 1] = kernel_rules_cnt; } - kernel_rule_t *kernel_rules_buf = (kernel_rule_t *) hccalloc (hashcat_ctx, kernel_rules_cnt, sizeof (kernel_rule_t)); + kernel_rule_t *kernel_rules_buf = (kernel_rule_t *) hccalloc (hashcat_ctx, kernel_rules_cnt, sizeof (kernel_rule_t)); VERIFY_PTR (kernel_rules_buf); for (u32 i = 0; i < kernel_rules_cnt; i++) { @@ -879,9 +879,9 @@ int kernel_rules_generate (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, const user_options_t *user_options = hashcat_ctx->user_options; u32 kernel_rules_cnt = 0; - kernel_rule_t *kernel_rules_buf = hccalloc (hashcat_ctx, user_options->rp_gen, sizeof (kernel_rule_t)); + kernel_rule_t *kernel_rules_buf = hccalloc (hashcat_ctx, user_options->rp_gen, sizeof (kernel_rule_t)); VERIFY_PTR (kernel_rules_buf); - char *rule_buf = (char *) hcmalloc (hashcat_ctx, RP_RULE_BUFSIZ); + char *rule_buf = (char *) hcmalloc (hashcat_ctx, RP_RULE_BUFSIZ); VERIFY_PTR (rule_buf); for (kernel_rules_cnt = 0; kernel_rules_cnt < user_options->rp_gen; kernel_rules_cnt++) { diff --git a/src/status.c b/src/status.c index f0c6b1a4f..1a63841e0 100644 --- a/src/status.c +++ b/src/status.c @@ -1347,9 +1347,9 @@ int status_progress_init (hashcat_ctx_t *hashcat_ctx) status_ctx_t *status_ctx = hashcat_ctx->status_ctx; hashes_t *hashes = hashcat_ctx->hashes; - status_ctx->words_progress_done = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); - status_ctx->words_progress_rejected = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); - status_ctx->words_progress_restored = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); + status_ctx->words_progress_done = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); VERIFY_PTR (status_ctx->words_progress_done); + status_ctx->words_progress_rejected = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); VERIFY_PTR (status_ctx->words_progress_rejected); + status_ctx->words_progress_restored = (u64 *) hccalloc (hashcat_ctx, hashes->salts_cnt, sizeof (u64)); VERIFY_PTR (status_ctx->words_progress_restored); return 0; } diff --git a/src/straight.c b/src/straight.c index a9a2609a5..5b2af2e43 100644 --- a/src/straight.c +++ b/src/straight.c @@ -20,20 +20,22 @@ #include "straight.h" #include "wordlist.h" -static void straight_ctx_add_wl (hashcat_ctx_t *hashcat_ctx, const char *dict) +static int straight_ctx_add_wl (hashcat_ctx_t *hashcat_ctx, const char *dict) { straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; if (straight_ctx->dicts_avail == straight_ctx->dicts_cnt) { - straight_ctx->dicts = (char **) hcrealloc (hashcat_ctx, straight_ctx->dicts, straight_ctx->dicts_avail * sizeof (char *), INCR_DICTS * sizeof (char *)); + straight_ctx->dicts = (char **) hcrealloc (hashcat_ctx, straight_ctx->dicts, straight_ctx->dicts_avail * sizeof (char *), INCR_DICTS * sizeof (char *)); VERIFY_PTR (straight_ctx->dicts); straight_ctx->dicts_avail += INCR_DICTS; } - straight_ctx->dicts[straight_ctx->dicts_cnt] = hcstrdup (hashcat_ctx, dict); + straight_ctx->dicts[straight_ctx->dicts_cnt] = hcstrdup (hashcat_ctx, dict); VERIFY_PTR (straight_ctx->dicts[straight_ctx->dicts_cnt]); straight_ctx->dicts_cnt++; + + return 0; } int straight_ctx_update_loop (hashcat_ctx_t *hashcat_ctx) @@ -198,7 +200,7 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) if ((user_options->rp_files_cnt == 0) && (user_options->rp_gen == 0)) { - straight_ctx->kernel_rules_buf = (kernel_rule_t *) hcmalloc (hashcat_ctx, sizeof (kernel_rule_t)); + straight_ctx->kernel_rules_buf = (kernel_rule_t *) hcmalloc (hashcat_ctx, sizeof (kernel_rule_t)); VERIFY_PTR (straight_ctx->kernel_rules_buf); straight_ctx->kernel_rules_buf[0].cmds[0] = RULE_OP_MANGLE_NOOP; @@ -304,7 +306,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) if (S_ISREG (l1_stat.st_mode)) { - straight_ctx_add_wl (hashcat_ctx, l1_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); + + if (rc == -1) return -1; } } } @@ -313,7 +317,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) } else { - straight_ctx_add_wl (hashcat_ctx, l0_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); + + if (rc == -1) return -1; } } @@ -373,7 +379,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) if (S_ISREG (l1_stat.st_mode)) { - straight_ctx_add_wl (hashcat_ctx, l1_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); + + if (rc == -1) return -1; } } } @@ -382,7 +390,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) } else { - straight_ctx_add_wl (hashcat_ctx, l0_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); + + if (rc == -1) return -1; } } @@ -433,7 +443,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) if (S_ISREG (l1_stat.st_mode)) { - straight_ctx_add_wl (hashcat_ctx, l1_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); + + if (rc == -1) return -1; } } } @@ -442,7 +454,9 @@ int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) } else { - straight_ctx_add_wl (hashcat_ctx, l0_filename); + const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); + + if (rc == -1) return -1; } } diff --git a/src/tuningdb.c b/src/tuningdb.c index 535289446..9153d53b1 100644 --- a/src/tuningdb.c +++ b/src/tuningdb.c @@ -67,7 +67,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx) tuning_db->enabled = true; - char *tuning_db_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); + char *tuning_db_file = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_TINY); VERIFY_PTR (tuning_db_file); snprintf (tuning_db_file, HCBUFSIZ_TINY - 1, "%s/%s", folder_config->shared_dir, TUNING_DB_FILE); @@ -86,17 +86,17 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx) // a bit over-allocated - tuning_db->alias_buf = (tuning_db_alias_t *) hccalloc (hashcat_ctx, num_lines + 1, sizeof (tuning_db_alias_t)); + tuning_db->alias_buf = (tuning_db_alias_t *) hccalloc (hashcat_ctx, num_lines + 1, sizeof (tuning_db_alias_t)); VERIFY_PTR (tuning_db->alias_buf); tuning_db->alias_cnt = 0; - tuning_db->entry_buf = (tuning_db_entry_t *) hccalloc (hashcat_ctx, num_lines + 1, sizeof (tuning_db_entry_t)); + tuning_db->entry_buf = (tuning_db_entry_t *) hccalloc (hashcat_ctx, num_lines + 1, sizeof (tuning_db_entry_t)); VERIFY_PTR (tuning_db->entry_buf); tuning_db->entry_cnt = 0; rewind (fp); int line_num = 0; - char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); + char *buf = (char *) hcmalloc (hashcat_ctx, HCBUFSIZ_LARGE); VERIFY_PTR (buf); while (!feof (fp)) { diff --git a/src/user_options.c b/src/user_options.c index 9c4ef6549..2e0c92e2d 100644 --- a/src/user_options.c +++ b/src/user_options.c @@ -108,7 +108,7 @@ static char DEF_MASK_CS_1[] = "?l?d?u"; static char DEF_MASK_CS_2[] = "?l?d"; static char DEF_MASK_CS_3[] = "?l?d*!$@_"; -void user_options_init (hashcat_ctx_t *hashcat_ctx) +int user_options_init (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; @@ -192,10 +192,12 @@ void user_options_init (hashcat_ctx_t *hashcat_ctx) user_options->weak_hash_threshold = WEAK_HASH_THRESHOLD; user_options->workload_profile = WORKLOAD_PROFILE; user_options->rp_files_cnt = 0; - user_options->rp_files = (char **) hccalloc (hashcat_ctx, 256, sizeof (char *)); + user_options->rp_files = (char **) hccalloc (hashcat_ctx, 256, sizeof (char *)); VERIFY_PTR (user_options->rp_files); user_options->hc_bin = PROGNAME; user_options->hc_argc = 0; user_options->hc_argv = NULL; + + return 0; } void user_options_destroy (hashcat_ctx_t *hashcat_ctx) diff --git a/src/wordlist.c b/src/wordlist.c index 4d8630442..afdc4dce7 100644 --- a/src/wordlist.c +++ b/src/wordlist.c @@ -58,7 +58,7 @@ u32 convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const u32 line return (line_len); } -void load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd) +int load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd) { wl_data_t *wl_data = hashcat_ctx->wl_data; @@ -70,15 +70,15 @@ void load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd) wl_data->buf[wl_data->cnt] = 0; - if (wl_data->cnt == 0) return; + if (wl_data->cnt == 0) return 0; - if (wl_data->buf[wl_data->cnt - 1] == '\n') return; + if (wl_data->buf[wl_data->cnt - 1] == '\n') return 0; while (!feof (fd)) { if (wl_data->cnt == wl_data->avail) { - wl_data->buf = (char *) hcrealloc (hashcat_ctx, wl_data->buf, wl_data->avail, wl_data->incr); + wl_data->buf = (char *) hcrealloc (hashcat_ctx, wl_data->buf, wl_data->avail, wl_data->incr); VERIFY_PTR (wl_data->buf); wl_data->avail += wl_data->incr; } @@ -103,7 +103,7 @@ void load_segment (hashcat_ctx_t *hashcat_ctx, FILE *fd) wl_data->buf[wl_data->cnt - 1] = '\n'; } - return; + return 0; } void get_next_word_lm (char *buf, u64 sz, u64 *len, u64 *off) @@ -414,7 +414,7 @@ u64 count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile) return (cnt); } -void wl_data_init (hashcat_ctx_t *hashcat_ctx) +int wl_data_init (hashcat_ctx_t *hashcat_ctx) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; user_options_t *user_options = hashcat_ctx->user_options; @@ -422,16 +422,16 @@ void wl_data_init (hashcat_ctx_t *hashcat_ctx) wl_data->enabled = false; - if (user_options->benchmark == true) return; - if (user_options->keyspace == true) return; - if (user_options->left == true) return; - if (user_options->opencl_info == true) return; - if (user_options->usage == true) return; - if (user_options->version == true) return; + if (user_options->benchmark == true) return 0; + if (user_options->keyspace == true) return 0; + if (user_options->left == true) return 0; + if (user_options->opencl_info == true) return 0; + if (user_options->usage == true) return 0; + if (user_options->version == true) return 0; wl_data->enabled = true; - wl_data->buf = (char *) hcmalloc (hashcat_ctx, user_options->segment_size); + wl_data->buf = (char *) hcmalloc (hashcat_ctx, user_options->segment_size); VERIFY_PTR (wl_data->buf); wl_data->avail = user_options->segment_size; wl_data->incr = user_options->segment_size; wl_data->cnt = 0; @@ -452,6 +452,8 @@ void wl_data_init (hashcat_ctx_t *hashcat_ctx) { wl_data->func = get_next_word_lm; } + + return 0; } void wl_data_destroy (hashcat_ctx_t *hashcat_ctx)