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

Update outfile.c and potfile.c function parameters

Browse Source
This commit is contained in:
jsteube 2016-10-06 15:40:27 +02:00
parent 0579f93402
commit 9b8092abf9
6 changed files with 204 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/outfile.h
View File

@ -14,12 +14,11 @@ void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_para
void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos);
void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len);
void outfile_init (outfile_ctx_t *outfile_ctx, const user_options_t *user_options);
void outfile_destroy (outfile_ctx_t *outfile_ctx);
void outfile_format_plain (outfile_ctx_t *outfile_ctx, const unsigned char *plain_ptr, const u32 plain_len);
void outfile_write_open (outfile_ctx_t *outfile_ctx);
void outfile_write_close (outfile_ctx_t *outfile_ctx);
void outfile_write (outfile_ctx_t *outfile_ctx, const char *out_buf, const unsigned char *plain_ptr, const u32 plain_len, const u64 crackpos, const unsigned char *username, const u32 user_len, const hashconfig_t *hashconfig);
int outfile_and_hashfile (outfile_ctx_t *outfile_ctx, const char *hashfile);
void outfile_init (hashcat_ctx_t *hashcat_ctx);
void outfile_destroy (hashcat_ctx_t *hashcat_ctx);
void outfile_write_open (hashcat_ctx_t *hashcat_ctx);
void outfile_write_close (hashcat_ctx_t *hashcat_ctx);
void outfile_write (hashcat_ctx_t *hashcat_ctx, const char *out_buf, const unsigned char *plain_ptr, const u32 plain_len, const u64 crackpos, const unsigned char *username, const u32 user_len);
int outfile_and_hashfile (hashcat_ctx_t *hashcat_ctx);
#endif // _OUTFILE_H

31
include/potfile.h
View File

@ -20,21 +20,20 @@ int sort_by_hash_t_salt_hccap (const void *v1, const void *v2);
void hc_qsort_r (void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *, void *), void *arg);
void *hc_bsearch_r (const void *key, const void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *, void *), void *arg);
void potfile_init (potfile_ctx_t *potfile_ctx, const user_options_t *user_options, const folder_config_t *folder_config);
void potfile_format_plain (potfile_ctx_t *potfile_ctx, const unsigned char *plain_ptr, const u32 plain_len);
int potfile_read_open (potfile_ctx_t *potfile_ctx);
void potfile_read_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig);
void potfile_read_close (potfile_ctx_t *potfile_ctx);
int potfile_write_open (potfile_ctx_t *potfile_ctx);
void potfile_write_close (potfile_ctx_t *potfile_ctx);
void potfile_write_append (potfile_ctx_t *potfile_ctx, const char *out_buf, u8 *plain_ptr, unsigned int plain_len);
void potfile_hash_alloc (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, const u32 num);
void potfile_hash_free (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig);
void potfile_show_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_ctx, char *input_buf, int input_len, hash_t *hashes_buf, int (*sort_by_pot) (const void *, const void *, void *));
void potfile_left_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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 (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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 (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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 (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, const hashes_t *hashes);
void potfile_destroy (potfile_ctx_t *potfile_ctx);
void 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);
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);
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 *));
int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx);
void potfile_destroy (hashcat_ctx_t *hashcat_ctx);
#endif // _POTFILE_H

36
src/hashcat.c
View File

@ -763,8 +763,6 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
outcheck_ctx_t *outcheck_ctx = hashcat_ctx->outcheck_ctx;
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
@ -799,13 +797,11 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
if (user_options->show == true || user_options->left == true)
{
outfile_write_open (outfile_ctx);
outfile_write_open (hashcat_ctx);
potfile_read_open (potfile_ctx);
potfile_read_parse (potfile_ctx, hashconfig);
potfile_read_close (potfile_ctx);
potfile_read_open (hashcat_ctx);
potfile_read_parse (hashcat_ctx);
potfile_read_close (hashcat_ctx);
}
/**
@ -832,9 +828,9 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
if (user_options->show == true || user_options->left == true)
{
outfile_write_close (outfile_ctx);
outfile_write_close (hashcat_ctx);
potfile_hash_free (potfile_ctx, hashconfig);
potfile_hash_free (hashcat_ctx);
return 0;
}
@ -849,7 +845,7 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
{
if (user_options->quiet == false) log_info_nn ("Comparing hashes with potfile entries...");
potfile_remove_cracks = potfile_remove_parse (potfile_ctx, hashconfig, hashes);
potfile_remove_cracks = potfile_remove_parse (hashcat_ctx);
}
/**
@ -880,7 +876,7 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
hashconfig_destroy (hashconfig);
potfile_destroy (potfile_ctx);
potfile_destroy (hashcat_ctx);
return 0;
}
@ -1080,7 +1076,7 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
* weak hash check is the first to write to potfile, so open it for writing from here
*/
const int rc_potfile_write = potfile_write_open (potfile_ctx);
const int rc_potfile_write = potfile_write_open (hashcat_ctx);
if (rc_potfile_write == -1) return -1;
@ -1208,7 +1204,7 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
opencl_session_destroy (hashcat_ctx);
potfile_write_close (potfile_ctx);
potfile_write_close (hashcat_ctx);
bitmap_ctx_destroy (hashcat_ctx);
@ -1249,8 +1245,6 @@ int hashcat (hashcat_ctx_t *hashcat_ctx, char *install_folder, char *shared_fold
logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_ctx;
loopback_ctx_t *loopback_ctx = hashcat_ctx->loopback_ctx;
outcheck_ctx_t *outcheck_ctx = hashcat_ctx->outcheck_ctx;
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
tuning_db_t *tuning_db = hashcat_ctx->tuning_db;
@ -1333,13 +1327,13 @@ int hashcat (hashcat_ctx_t *hashcat_ctx, char *install_folder, char *shared_fold
* outfile itself
*/
outfile_init (outfile_ctx, user_options);
outfile_init (hashcat_ctx);
/**
* Sanity check for hashfile vs outfile (should not point to the same physical file)
*/
const int rc_outfile_and_hashfile = outfile_and_hashfile (outfile_ctx, user_options_extra->hc_hash);
const int rc_outfile_and_hashfile = outfile_and_hashfile (hashcat_ctx);
if (rc_outfile_and_hashfile == -1) return -1;
@ -1349,7 +1343,7 @@ int hashcat (hashcat_ctx_t *hashcat_ctx, char *install_folder, char *shared_fold
* plus it depends on hash_mode, so we continue using it in outer_loop
*/
potfile_init (potfile_ctx, user_options, folder_config);
potfile_init (hashcat_ctx);
/**
* dictstat init
@ -1508,11 +1502,11 @@ int hashcat (hashcat_ctx_t *hashcat_ctx, char *install_folder, char *shared_fold
dictstat_destroy (dictstat_ctx);
potfile_destroy (potfile_ctx);
potfile_destroy (hashcat_ctx);
induct_ctx_destroy (induct_ctx);
outfile_destroy (outfile_ctx);
outfile_destroy (hashcat_ctx);
outcheck_ctx_destroy (outcheck_ctx);

39
src/hashes.c
View File

@ -222,7 +222,6 @@ void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
hashes_t *hashes = hashcat_ctx->hashes;
loopback_ctx_t *loopback_ctx = hashcat_ctx->loopback_ctx;
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
@ -263,19 +262,19 @@ void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
// no need for locking, we're in a mutex protected function
potfile_write_append (potfile_ctx, out_buf, plain_ptr, plain_len);
potfile_write_append (hashcat_ctx, out_buf, plain_ptr, plain_len);
// outfile, can be either to file or stdout
// if an error occurs opening the file, send to stdout as fallback
// the fp gets opened for each cracked hash so that the user can modify (move) the outfile while hashcat runs
outfile_write_open (outfile_ctx);
outfile_write_open (hashcat_ctx);
if (outfile_ctx->filename == NULL) if (user_options->quiet == false) clear_prompt ();
outfile_write (outfile_ctx, out_buf, plain_ptr, plain_len, crackpos, NULL, 0, hashconfig);
outfile_write (hashcat_ctx, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
outfile_write_close (outfile_ctx);
outfile_write_close (hashcat_ctx);
if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK))
{
@ -438,8 +437,6 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
@ -783,8 +780,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
tmp_salt->salt_len += 1 + 12 + 1 + 12;
}
if (user_options->show == true) potfile_show_request (potfile_ctx, hashconfig, outfile_ctx, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf);
if (user_options->left == true) potfile_left_request (potfile_ctx, hashconfig, outfile_ctx, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf);
if (user_options->show == true) potfile_show_request (hashcat_ctx, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf);
if (user_options->left == true) potfile_left_request (hashcat_ctx, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf);
hashes_cnt++;
}
@ -831,8 +828,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
{
if (user_options->show == true) potfile_show_request_lm (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->left == true) potfile_left_request_lm (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->show == true) potfile_show_request_lm (hashcat_ctx, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->left == true) potfile_left_request_lm (hashcat_ctx, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot);
}
}
else
@ -841,8 +838,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if (parser_status == PARSER_OK)
{
if (user_options->show == true) potfile_show_request (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->show == true) potfile_show_request (hashcat_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (hashcat_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
}
if (parser_status == PARSER_OK)
@ -861,8 +858,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if (parser_status == PARSER_OK)
{
if (user_options->show == true) potfile_show_request (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (potfile_ctx, hashconfig, outfile_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->show == true) potfile_show_request (hashcat_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (hashcat_ctx, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot);
}
if (parser_status == PARSER_OK)
@ -992,8 +989,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
// show / left
if (user_options->show == true) potfile_show_request_lm (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->left == true) potfile_left_request_lm (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->show == true) potfile_show_request_lm (hashcat_ctx, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot);
if (user_options->left == true) potfile_left_request_lm (hashcat_ctx, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot);
}
else
{
@ -1008,8 +1005,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if (user_options->quiet == false) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100);
if (user_options->show == true) potfile_show_request (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->show == true) potfile_show_request (hashcat_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (hashcat_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
hashes_cnt++;
}
@ -1027,8 +1024,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if (user_options->quiet == false) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100);
if (user_options->show == true) potfile_show_request (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (potfile_ctx, hashconfig, outfile_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->show == true) potfile_show_request (hashcat_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
if (user_options->left == true) potfile_left_request (hashcat_ctx, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot);
hashes_cnt++;
}

73
src/outfile.c
View File

@ -256,30 +256,10 @@ void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_para
}
}
void outfile_init (outfile_ctx_t *outfile_ctx, const user_options_t *user_options)
static void outfile_format_plain (hashcat_ctx_t *hashcat_ctx, const unsigned char *plain_ptr, const u32 plain_len)
{
if (user_options->outfile == NULL)
{
outfile_ctx->fp = stdout;
outfile_ctx->filename = NULL;
}
else
{
outfile_ctx->fp = NULL;
outfile_ctx->filename = user_options->outfile;
}
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
outfile_ctx->outfile_format = user_options->outfile_format;
outfile_ctx->outfile_autohex = user_options->outfile_autohex;
}
void outfile_destroy (outfile_ctx_t *outfile_ctx)
{
memset (outfile_ctx, 0, sizeof (outfile_ctx_t));
}
void outfile_format_plain (outfile_ctx_t *outfile_ctx, const unsigned char *plain_ptr, const u32 plain_len)
{
bool needs_hexify = false;
if (outfile_ctx->outfile_autohex == true)
@ -319,8 +299,37 @@ void outfile_format_plain (outfile_ctx_t *outfile_ctx, const unsigned char *plai
}
}
void outfile_write_open (outfile_ctx_t *outfile_ctx)
void outfile_init (hashcat_ctx_t *hashcat_ctx)
{
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
if (user_options->outfile == NULL)
{
outfile_ctx->fp = stdout;
outfile_ctx->filename = NULL;
}
else
{
outfile_ctx->fp = NULL;
outfile_ctx->filename = user_options->outfile;
}
outfile_ctx->outfile_format = user_options->outfile_format;
outfile_ctx->outfile_autohex = user_options->outfile_autohex;
}
void outfile_destroy (hashcat_ctx_t *hashcat_ctx)
{
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
memset (outfile_ctx, 0, sizeof (outfile_ctx_t));
}
void outfile_write_open (hashcat_ctx_t *hashcat_ctx)
{
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
if (outfile_ctx->filename == NULL) return;
outfile_ctx->fp = fopen (outfile_ctx->filename, "ab");
@ -334,15 +343,20 @@ void outfile_write_open (outfile_ctx_t *outfile_ctx)
}
}
void outfile_write_close (outfile_ctx_t *outfile_ctx)
void outfile_write_close (hashcat_ctx_t *hashcat_ctx)
{
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
if (outfile_ctx->fp == stdout) return;
fclose (outfile_ctx->fp);
}
void outfile_write (outfile_ctx_t *outfile_ctx, const char *out_buf, const unsigned char *plain_ptr, const u32 plain_len, const u64 crackpos, const unsigned char *username, const u32 user_len, const hashconfig_t *hashconfig)
void outfile_write (hashcat_ctx_t *hashcat_ctx, const char *out_buf, const unsigned char *plain_ptr, const u32 plain_len, const u64 crackpos, const unsigned char *username, const u32 user_len)
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
if (outfile_ctx->outfile_format & OUTFILE_FMT_HASH)
{
fprintf (outfile_ctx->fp, "%s", out_buf);
@ -370,7 +384,7 @@ void outfile_write (outfile_ctx_t *outfile_ctx, const char *out_buf, const unsig
if (outfile_ctx->outfile_format & OUTFILE_FMT_PLAIN)
{
outfile_format_plain (outfile_ctx, plain_ptr, plain_len);
outfile_format_plain (hashcat_ctx, plain_ptr, plain_len);
if (outfile_ctx->outfile_format & (OUTFILE_FMT_HEXPLAIN | OUTFILE_FMT_CRACKPOS))
{
@ -399,8 +413,13 @@ void outfile_write (outfile_ctx_t *outfile_ctx, const char *out_buf, const unsig
fputs (EOL, outfile_ctx->fp);
}
int outfile_and_hashfile (outfile_ctx_t *outfile_ctx, const char *hashfile)
int outfile_and_hashfile (hashcat_ctx_t *hashcat_ctx)
{
outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
char *hashfile = user_options_extra->hc_hash;
if (hashfile == NULL) return 0;
char *outfile = outfile_ctx->filename;

165
src/potfile.c
View File

@ -146,48 +146,10 @@ void *hc_bsearch_r (const void *key, const void *base, size_t nmemb, size_t size
return (NULL);
}
void potfile_init (potfile_ctx_t *potfile_ctx, const user_options_t *user_options, const folder_config_t *folder_config)
static void potfile_format_plain (hashcat_ctx_t *hashcat_ctx, const unsigned char *plain_ptr, const u32 plain_len)
{
potfile_ctx->enabled = false;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (user_options->benchmark == true) return;
if (user_options->keyspace == true) return;
if (user_options->opencl_info == true) return;
if (user_options->stdout_flag == true) return;
if (user_options->usage == true) return;
if (user_options->version == true) return;
if (user_options->potfile_disable == true) return;
potfile_ctx->enabled = true;
if (user_options->potfile_path == NULL)
{
potfile_ctx->filename = (char *) mymalloc (HCBUFSIZ_TINY);
potfile_ctx->fp = NULL;
snprintf (potfile_ctx->filename, HCBUFSIZ_TINY - 1, "%s/hashcat.potfile", folder_config->profile_dir);
}
else
{
potfile_ctx->filename = mystrdup (user_options->potfile_path);
potfile_ctx->fp = NULL;
}
potfile_ctx->pot = NULL;
potfile_ctx->pot_cnt = 0;
potfile_ctx->pot_avail = 0;
potfile_ctx->pot_hashes_avail = 0;
}
void potfile_destroy (potfile_ctx_t *potfile_ctx)
{
if (potfile_ctx->enabled == false) return;
memset (potfile_ctx, 0, sizeof (potfile_ctx_t));
}
void potfile_format_plain (potfile_ctx_t *potfile_ctx, const unsigned char *plain_ptr, const u32 plain_len)
{
if (potfile_ctx->enabled == false) return;
bool needs_hexify = false;
@ -226,8 +188,56 @@ void potfile_format_plain (potfile_ctx_t *potfile_ctx, const unsigned char *plai
}
}
int potfile_read_open (potfile_ctx_t *potfile_ctx)
void potfile_init (hashcat_ctx_t *hashcat_ctx)
{
folder_config_t *folder_config = hashcat_ctx->folder_config;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
potfile_ctx->enabled = false;
if (user_options->benchmark == true) return;
if (user_options->keyspace == true) return;
if (user_options->opencl_info == true) return;
if (user_options->stdout_flag == true) return;
if (user_options->usage == true) return;
if (user_options->version == true) return;
if (user_options->potfile_disable == true) return;
potfile_ctx->enabled = true;
if (user_options->potfile_path == NULL)
{
potfile_ctx->filename = (char *) mymalloc (HCBUFSIZ_TINY);
potfile_ctx->fp = NULL;
snprintf (potfile_ctx->filename, HCBUFSIZ_TINY - 1, "%s/hashcat.potfile", folder_config->profile_dir);
}
else
{
potfile_ctx->filename = mystrdup (user_options->potfile_path);
potfile_ctx->fp = NULL;
}
potfile_ctx->pot = NULL;
potfile_ctx->pot_cnt = 0;
potfile_ctx->pot_avail = 0;
potfile_ctx->pot_hashes_avail = 0;
}
void potfile_destroy (hashcat_ctx_t *hashcat_ctx)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
memset (potfile_ctx, 0, sizeof (potfile_ctx_t));
}
int potfile_read_open (hashcat_ctx_t *hashcat_ctx)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return 0;
potfile_ctx->fp = fopen (potfile_ctx->filename, "rb");
@ -242,8 +252,11 @@ int potfile_read_open (potfile_ctx_t *potfile_ctx)
return 0;
}
void potfile_read_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig)
void 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->fp == NULL) return;
@ -269,7 +282,7 @@ void potfile_read_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashcon
if (potfile_ctx->pot_cnt == potfile_ctx->pot_hashes_avail)
{
potfile_hash_alloc (potfile_ctx, hashconfig, INCR_POT);
potfile_hash_alloc (hashcat_ctx, INCR_POT);
}
int parser_status;
@ -349,8 +362,10 @@ void potfile_read_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashcon
hc_qsort_r (potfile_ctx->pot, potfile_ctx->pot_cnt, sizeof (pot_t), sort_by_pot, (void *) hashconfig);
}
void potfile_read_close (potfile_ctx_t *potfile_ctx)
void potfile_read_close (hashcat_ctx_t *hashcat_ctx)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
if (potfile_ctx->fp == NULL) return;
@ -358,8 +373,10 @@ void potfile_read_close (potfile_ctx_t *potfile_ctx)
fclose (potfile_ctx->fp);
}
int potfile_write_open (potfile_ctx_t *potfile_ctx)
int potfile_write_open (hashcat_ctx_t *hashcat_ctx)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return 0;
potfile_ctx->fp = fopen (potfile_ctx->filename, "ab");
@ -374,30 +391,37 @@ int potfile_write_open (potfile_ctx_t *potfile_ctx)
return 0;
}
void potfile_write_close (potfile_ctx_t *potfile_ctx)
void potfile_write_close (hashcat_ctx_t *hashcat_ctx)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
fclose (potfile_ctx->fp);
}
void potfile_write_append (potfile_ctx_t *potfile_ctx, const char *out_buf, u8 *plain_ptr, unsigned int plain_len)
void potfile_write_append (hashcat_ctx_t *hashcat_ctx, const char *out_buf, u8 *plain_ptr, unsigned int plain_len)
{
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
FILE *fp = potfile_ctx->fp;
fprintf (fp, "%s:", out_buf);
potfile_format_plain (potfile_ctx, plain_ptr, plain_len);
potfile_format_plain (hashcat_ctx, plain_ptr, plain_len);
fputc ('\n', fp);
fflush (fp);
}
void potfile_hash_alloc (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, const u32 num)
void 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;
u32 pos = 0;
@ -426,8 +450,11 @@ void potfile_hash_alloc (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashcon
}
}
void potfile_hash_free (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig)
void potfile_hash_free (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;
for (u32 i = 0; i < potfile_ctx->pot_cnt; i++)
@ -452,8 +479,11 @@ void potfile_hash_free (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconf
myfree (potfile_ctx->pot);
}
void potfile_show_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_ctx, char *input_buf, int input_len, hash_t *hashes_buf, int (*sort_by_pot) (const void *, const void *, void *))
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 *))
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
pot_t pot_key;
@ -487,12 +517,15 @@ void potfile_show_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashc
// do output the line
outfile_write (outfile_ctx, input_buf, (const unsigned char *) pot_ptr->plain_buf, pot_ptr->plain_len, 0, username, user_len, hashconfig);
outfile_write (hashcat_ctx, input_buf, (const unsigned char *) pot_ptr->plain_buf, pot_ptr->plain_len, 0, username, user_len);
}
}
void potfile_left_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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 *))
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
pot_t pot_key;
@ -507,12 +540,15 @@ void potfile_left_request (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashc
input_buf[input_len] = 0;
outfile_write (outfile_ctx, input_buf, NULL, 0, 0, NULL, 0, hashconfig);
outfile_write (hashcat_ctx, input_buf, NULL, 0, 0, NULL, 0);
}
}
void potfile_show_request_lm (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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_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;
// left
@ -625,7 +661,7 @@ void potfile_show_request_lm (potfile_ctx_t *potfile_ctx, const hashconfig_t *ha
// do output the line
outfile_write (outfile_ctx, input_buf, (unsigned char *) pot_ptr.plain_buf, pot_ptr.plain_len, 0, username, user_len, hashconfig);
outfile_write (hashcat_ctx, input_buf, (unsigned char *) pot_ptr.plain_buf, pot_ptr.plain_len, 0, username, user_len);
if (weak_hash_found == 1) myfree (pot_right_ptr);
@ -633,8 +669,11 @@ void potfile_show_request_lm (potfile_ctx_t *potfile_ctx, const hashconfig_t *ha
if (right_part_masked == 1) myfree (pot_right_ptr);
}
void potfile_left_request_lm (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, outfile_ctx_t *outfile_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 *))
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx;
if (potfile_ctx->enabled == false) return;
// left
@ -708,15 +747,19 @@ void potfile_left_request_lm (potfile_ctx_t *potfile_ctx, const hashconfig_t *ha
hash_output[user_len + 16] = 0;
}
outfile_write (outfile_ctx, hash_output, NULL, 0, 0, NULL, 0, hashconfig);
outfile_write (hashcat_ctx, hash_output, NULL, 0, 0, NULL, 0);
myfree (hash_output);
if (weak_hash_found == 1) myfree (pot_right_ptr);
}
int potfile_remove_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashconfig, const hashes_t *hashes)
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 0;
hash_t *hashes_buf = hashes->hashes_buf;
@ -754,7 +797,7 @@ int potfile_remove_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashco
hash_buf.esalt = mymalloc (hashconfig->esalt_size);
}
const int rc = potfile_read_open (potfile_ctx);
const int rc = potfile_read_open (hashcat_ctx);
if (rc == -1) return 0;
@ -909,7 +952,7 @@ int potfile_remove_parse (potfile_ctx_t *potfile_ctx, const hashconfig_t *hashco
myfree (line_buf);
potfile_read_close (potfile_ctx);
potfile_read_close (hashcat_ctx);
if (hashconfig->esalt_size)
{