int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
{
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
user_options_t *user_options = hashcat_ctx->user_options;
mask_ctx->enabled = false;
if (user_options->example_hashes == 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;
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) return 0;
if (user_options->attack_mode == ATTACK_MODE_COMBI) return 0;
mask_ctx->enabled = true;
mask_ctx->root_table_buf = (hcstat_table_t *) hccalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
mask_ctx->markov_table_buf = (hcstat_table_t *) hccalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
const int rc_setup_tbl = sp_setup_tbl (hashcat_ctx);
if (rc_setup_tbl == -1) return -1;
mask_ctx->root_css_buf = (cs_t *) hccalloc (SP_PW_MAX, sizeof (cs_t));
mask_ctx->markov_css_buf = (cs_t *) hccalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
mask_ctx->css_cnt = 0;
mask_ctx->css_buf = NULL;
mask_ctx->mask_from_file = false;
mask_ctx->masks = NULL;
mask_ctx->masks_pos = 0;
mask_ctx->masks_cnt = 0;
mask_ctx->mfs = (mf_t *) hccalloc (MAX_MFS, sizeof (mf_t));
mp_setup_sys (mask_ctx->mp_sys);
if (user_options->custom_charset_1) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_1, 0); if (rc == -1) return -1; }
if (user_options->custom_charset_2) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_2, 1); if (rc == -1) return -1; }
if (user_options->custom_charset_3) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_3, 2); if (rc == -1) return -1; }
if (user_options->custom_charset_4) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_4, 3); if (rc == -1) return -1; }
if (user_options->attack_mode == ATTACK_MODE_BF)
{
if (user_options->benchmark == false)
{
if (user_options_extra->hc_workc)
{
char *arg = user_options_extra->hc_workv[0];
if (hc_path_exist (arg) == false)
{
const int rc = mask_append (hashcat_ctx, arg, NULL);
if (rc == -1) return -1;
}
else
{
mask_ctx->mask_from_file = true;
for (int i = 0; i < user_options_extra->hc_workc; i++)
{
arg = user_options_extra->hc_workv[i];
if (hc_path_is_file (arg) == true)
{
FILE *mask_fp = fopen (arg, "r");
if (mask_fp == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
return -1;
}
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
while (!feof (mask_fp))
{
const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue;
if (line_buf[0] == '#') continue;
char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len);
char *prepend_buf = NULL;
if (line_buf != mask_buf)
{
// if we have custom charsets
prepend_buf = line_buf;
mask_buf[-1] = 0;
}
const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf);
if (rc == -1)
{
fclose (mask_fp);
return -1;
}
}
hcfree (line_buf);
fclose (mask_fp);
}
else
{
event_log_error (hashcat_ctx, "%s: unsupported file type.", arg);
return -1;
}
}
}
}
else
{
const char *mask = DEF_MASK;
const int rc = mask_append (hashcat_ctx, mask, NULL);
if (rc == -1) return -1;
}
}
else
{
const char *mask = hashconfig_benchmark_mask (hashcat_ctx);
const int rc = mask_append (hashcat_ctx, mask, NULL);
if (rc == -1) return -1;
}
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
// display
char *arg = user_options_extra->hc_workv[user_options_extra->hc_workc - 1];
// mod
if (hc_path_exist (arg) == false)
{
const int rc = mask_append (hashcat_ctx, arg, NULL);
if (rc == -1) return -1;
}
else
{
if (hc_path_is_file (arg) == true)
{
mask_ctx->mask_from_file = true;
FILE *mask_fp = fopen (arg, "r");
if (mask_fp == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
return -1;
}
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
while (!feof (mask_fp))
{
const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue;
if (line_buf[0] == '#') continue;
char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len);
char *prepend_buf = NULL;
if (line_buf != mask_buf)
{
// if we have custom charsets
prepend_buf = line_buf;
mask_buf[-1] = 0;
}
const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf);
if (rc == -1)
{
fclose (mask_fp);
return -1;
}
}
hcfree (line_buf);
fclose (mask_fp);
}
else
{
event_log_error (hashcat_ctx, "%s: unsupported file type.", arg);
return -1;
}
}
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
// display
char *arg = user_options_extra->hc_workv[0];
// mod
if (hc_path_exist (arg) == false)
{
const int rc = mask_append (hashcat_ctx, arg, NULL);
if (rc == -1) return -1;
}
else
{
if (hc_path_is_file (arg) == true)
{
mask_ctx->mask_from_file = true;
FILE *mask_fp = fopen (arg, "r");
if (mask_fp == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", arg, strerror (errno));
return -1;
}
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
while (!feof (mask_fp))
{
const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue;
if (line_buf[0] == '#') continue;
char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len);
char *prepend_buf = NULL;
if (line_buf != mask_buf)
{
// if we have custom charsets
prepend_buf = line_buf;
mask_buf[-1] = 0;
}
const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf);
if (rc == -1)
{
fclose (mask_fp);
return -1;
}
}
hcfree (line_buf);
fclose (mask_fp);
}
else
{
event_log_error (hashcat_ctx, "%s: unsupported file type.", arg);
return -1;
}
}
}
if (mask_ctx->masks_cnt == 0)
{
event_log_error (hashcat_ctx, "Invalid mask.");
return -1;
}
mask_ctx->mask = mask_ctx->masks[0];
return 0;
}
int straight_ctx_init (hashcat_ctx_t *hashcat_ctx)
{
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
user_options_t *user_options = hashcat_ctx->user_options;
straight_ctx->enabled = false;
if (user_options->example_hashes == 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;
if (user_options->attack_mode == ATTACK_MODE_BF) return 0;
straight_ctx->enabled = true;
/**
* generate NOP rules
*/
if ((user_options->rp_files_cnt == 0) && (user_options->rp_gen == 0))
{
straight_ctx->kernel_rules_buf = (kernel_rule_t *) hcmalloc (sizeof (kernel_rule_t));
straight_ctx->kernel_rules_buf[0].cmds[0] = RULE_OP_MANGLE_NOOP;
straight_ctx->kernel_rules_cnt = 1;
}
else
{
if (user_options->rp_files_cnt)
{
const int rc_kernel_load = kernel_rules_load (hashcat_ctx, &straight_ctx->kernel_rules_buf, &straight_ctx->kernel_rules_cnt);
if (rc_kernel_load == -1) return -1;
}
else if (user_options->rp_gen)
{
const int rc_kernel_generate = kernel_rules_generate (hashcat_ctx, &straight_ctx->kernel_rules_buf, &straight_ctx->kernel_rules_cnt);
if (rc_kernel_generate == -1) return -1;
}
}
/**
* wordlist based work
*/
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
if (user_options_extra->wordlist_mode == WL_MODE_FILE)
{
for (int i = 0; i < user_options_extra->hc_workc; i++)
{
char *l0_filename = user_options_extra->hc_workv[i];
// at this point we already verified the path actually exist and is readable
if (hc_path_is_directory (l0_filename) == true)
{
char **dictionary_files;
dictionary_files = scan_directory (l0_filename);
if (dictionary_files != NULL)
{
qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
for (int d = 0; dictionary_files[d] != NULL; d++)
{
char *l1_filename = dictionary_files[d];
if (hc_path_read (l1_filename) == false)
{
event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno));
hcfree (dictionary_files);
return -1;
}
if (hc_path_is_file (l1_filename) == true)
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename);
if (rc == -1)
{
hcfree (dictionary_files);
return -1;
}
}
}
}
hcfree (dictionary_files);
}
else
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename);
if (rc == -1) return -1;
}
}
if (straight_ctx->dicts_cnt == 0)
{
event_log_error (hashcat_ctx, "No usable dictionary file found.");
return -1;
}
}
}
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
}
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
for (int i = 0; i < user_options_extra->hc_workc - 1; i++)
{
char *l0_filename = user_options_extra->hc_workv[i];
// at this point we already verified the path actually exist and is readable
if (hc_path_is_directory (l0_filename) == true)
{
char **dictionary_files;
dictionary_files = scan_directory (l0_filename);
if (dictionary_files != NULL)
{
qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
for (int d = 0; dictionary_files[d] != NULL; d++)
{
char *l1_filename = dictionary_files[d];
if (hc_path_read (l1_filename) == false)
{
event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno));
hcfree (dictionary_files);
return -1;
}
if (hc_path_is_file (l1_filename) == true)
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename);
if (rc == -1)
{
hcfree (dictionary_files);
return -1;
}
}
}
}
hcfree (dictionary_files);
}
else
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename);
if (rc == -1) return -1;
}
}
if (straight_ctx->dicts_cnt == 0)
{
event_log_error (hashcat_ctx, "No usable dictionary file found.");
return -1;
}
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
for (int i = 1; i < user_options_extra->hc_workc; i++)
{
char *l0_filename = user_options_extra->hc_workv[i];
// at this point we already verified the path actually exist and is readable
if (hc_path_is_directory (l0_filename) == true)
{
char **dictionary_files;
dictionary_files = scan_directory (l0_filename);
if (dictionary_files != NULL)
{
qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
for (int d = 0; dictionary_files[d] != NULL; d++)
{
char *l1_filename = dictionary_files[d];
if (hc_path_read (l1_filename) == false)
{
event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno));
hcfree (dictionary_files);
return -1;
}
if (hc_path_is_file (l1_filename) == true)
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename);
if (rc == -1)
{
hcfree (dictionary_files);
return -1;
}
}
}
}
hcfree (dictionary_files);
}
else
{
const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename);
if (rc == -1) return -1;
}
}
if (straight_ctx->dicts_cnt == 0)
{
event_log_error (hashcat_ctx, "No usable dictionary file found.");
return -1;
}
}
return 0;
}
