void test_architecture_event_interrupt_02(void)
{
TEST_ENTER();
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0);
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1);
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2);
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 0,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_56),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 1,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_57),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 2,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_58),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_enable() != STATUS_OK)
TEST_ERROR("[event_enable] error");
asm volatile("int $56");
asm volatile("int $57");
asm volatile("int $58");
if (event_disable() != STATUS_OK)
TEST_ERROR("[event_disable] error");
if (thrown != 3)
TEST_ERROR("some interrupt events have not been caught");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0) != STATUS_OK)
TEST_ERROR("[event_release] error");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1) != STATUS_OK)
TEST_ERROR("[event_release] error");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2) != STATUS_OK)
TEST_ERROR("[event_release] error");
TEST_SIGNATURE(cd09iwfjg9gerkg43hg);
TEST_LEAVE();
}
void test_architecture_event_pic_02(void)
{
t_uint8 mask;
TEST_ENTER();
if (event_reserve(32 + 9,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_pic_02),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
ARCHITECTURE_INB(TEST_MASTER_PORT_B, mask);
if ((mask & (1 << 2)) != 0)
TEST_ERROR("invalid PIC mask");
ARCHITECTURE_INB(TEST_SLAVE_PORT_B, mask);
if (mask != 0xfd)
TEST_ERROR("invalid PIC mask");
TEST_SIGNATURE(vniwojw0f32wg3hh);
TEST_LEAVE();
}
int potfile_handle_left (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;
hash_t *hashes_buf = hashes->hashes_buf;
u32 salts_cnt = hashes->salts_cnt;
salt_t *salts_buf = hashes->salts_buf;
if (hashconfig->hash_mode == 3000)
{
for (u32 salt_idx = 0; salt_idx < salts_cnt; salt_idx++)
{
salt_t *salt_buf = salts_buf + salt_idx;
u32 digests_cnt = salt_buf->digests_cnt;
for (u32 digest_idx = 0; digest_idx < digests_cnt; digest_idx++)
{
const u32 hashes_idx = salt_buf->digests_offset + digest_idx;
u32 *digests_shown = hashes->digests_shown;
hash_t *hash1 = &hashes_buf[hashes_idx];
hash_t *hash2 = NULL;
int split_neighbor = -1;
// find out if at least one of the parts has been cracked
if (hash1->hash_info->split->split_origin == SPLIT_ORIGIN_LEFT)
{
split_neighbor = hash1->hash_info->split->split_neighbor;
hash2 = &hashes_buf[split_neighbor];
if ((digests_shown[hashes_idx] == 1) && (digests_shown[split_neighbor] == 1)) continue;
}
else if (hash1->hash_info->split->split_origin == SPLIT_ORIGIN_NONE)
{
if (digests_shown[hashes_idx] == 1) continue;
}
else
{
// SPLIT_ORIGIN_RIGHT are not handled this way
continue;
}
u8 *out_buf = potfile_ctx->out_buf;
out_buf[0] = 0;
ascii_digest (hashcat_ctx, (char *) out_buf + 0, HCBUFSIZ_LARGE - 0, salt_idx, digest_idx);
if (hash2)
{
ascii_digest (hashcat_ctx, (char *) out_buf + 16, HCBUFSIZ_LARGE - 16, salt_idx, split_neighbor);
}
// user
unsigned char *username = NULL;
u32 user_len = 0;
user_t *user = hash1->hash_info->user;
if (user)
{
username = (unsigned char *) (user->user_name);
user_len = user->user_len;
username[user_len] = 0;
}
u8 *tmp_buf = potfile_ctx->tmp_buf;
tmp_buf[0] = 0;
const int tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, NULL, 0, 0, username, user_len, (char *) tmp_buf);
EVENT_DATA (EVENT_POTFILE_HASH_LEFT, tmp_buf, tmp_len);
}
}
}
else
{
for (u32 salt_idx = 0; salt_idx < salts_cnt; salt_idx++)
{
salt_t *salt_buf = salts_buf + salt_idx;
u32 digests_cnt = salt_buf->digests_cnt;
for (u32 digest_idx = 0; digest_idx < digests_cnt; digest_idx++)
{
const u32 hashes_idx = salt_buf->digests_offset + digest_idx;
u32 *digests_shown = hashes->digests_shown;
if (digests_shown[hashes_idx] == 1) continue;
u8 *out_buf = potfile_ctx->out_buf;
out_buf[0] = 0;
ascii_digest (hashcat_ctx, (char *) out_buf, HCBUFSIZ_LARGE, salt_idx, digest_idx);
hash_t *hash = &hashes_buf[hashes_idx];
// user
unsigned char *username = NULL;
u32 user_len = 0;
if (hash->hash_info != NULL)
{
user_t *user = hash->hash_info->user;
if (user)
{
username = (unsigned char *) (user->user_name);
user_len = user->user_len;
username[user_len] = 0;
}
}
u8 *tmp_buf = potfile_ctx->tmp_buf;
tmp_buf[0] = 0;
const int tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, NULL, 0, 0, username, user_len, (char *) tmp_buf);
EVENT_DATA (EVENT_POTFILE_HASH_LEFT, tmp_buf, tmp_len);
}
}
}
return 0;
}
int potfile_handle_show (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;
hash_t *hashes_buf = hashes->hashes_buf;
u32 salts_cnt = hashes->salts_cnt;
salt_t *salts_buf = hashes->salts_buf;
if (hashconfig->hash_mode == 3000)
{
for (u32 salt_idx = 0; salt_idx < salts_cnt; salt_idx++)
{
salt_t *salt_buf = salts_buf + salt_idx;
u32 digests_cnt = salt_buf->digests_cnt;
for (u32 digest_idx = 0; digest_idx < digests_cnt; digest_idx++)
{
const u32 hashes_idx = salt_buf->digests_offset + digest_idx;
u32 *digests_shown = hashes->digests_shown;
hash_t *hash1 = &hashes_buf[hashes_idx];
hash_t *hash2 = NULL;
int split_neighbor = -1;
// find out if at least one of the parts has been cracked
if (hash1->hash_info->split->split_origin == SPLIT_ORIGIN_LEFT)
{
split_neighbor = hash1->hash_info->split->split_neighbor;
hash2 = &hashes_buf[split_neighbor];
if ((digests_shown[hashes_idx] == 0) && (digests_shown[split_neighbor] == 0)) continue;
}
else if (hash1->hash_info->split->split_origin == SPLIT_ORIGIN_NONE)
{
if (digests_shown[hashes_idx] == 0) continue;
}
else
{
// SPLIT_ORIGIN_RIGHT are not handled this way
continue;
}
u8 *out_buf = potfile_ctx->out_buf;
out_buf[0] = 0;
ascii_digest (hashcat_ctx, (char *) out_buf + 0, HCBUFSIZ_LARGE - 0, salt_idx, digest_idx);
if (hash2)
{
ascii_digest (hashcat_ctx, (char *) out_buf + 16, HCBUFSIZ_LARGE - 16, salt_idx, split_neighbor);
}
// user
unsigned char *username = NULL;
u32 user_len = 0;
user_t *user = hash1->hash_info->user;
if (user)
{
username = (unsigned char *) (user->user_name);
user_len = user->user_len;
username[user_len] = 0;
}
u8 *tmp_buf = potfile_ctx->tmp_buf;
tmp_buf[0] = 0;
u8 mixed_buf[20] = { 0 };
u8 mixed_len = 0;
if (digests_shown[hashes_idx] == 1)
{
memcpy (mixed_buf + mixed_len, hash1->pw_buf, hash1->pw_len);
mixed_len += hash1->pw_len;
}
else
{
memcpy (mixed_buf + mixed_len, LM_MASKED_PLAIN, strlen (LM_MASKED_PLAIN));
mixed_len += strlen (LM_MASKED_PLAIN);
}
if (hash2)
{
if (digests_shown[split_neighbor] == 1)
{
memcpy (mixed_buf + mixed_len, hash2->pw_buf, hash2->pw_len);
mixed_len += hash2->pw_len;
}
else
{
memcpy (mixed_buf + mixed_len, LM_MASKED_PLAIN, strlen (LM_MASKED_PLAIN));
mixed_len += strlen (LM_MASKED_PLAIN);
}
}
const int tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, (u8 *) mixed_buf, mixed_len, 0, username, user_len, (char *) tmp_buf);
EVENT_DATA (EVENT_POTFILE_HASH_SHOW, tmp_buf, tmp_len);
}
}
}
else
{
for (u32 salt_idx = 0; salt_idx < salts_cnt; salt_idx++)
{
salt_t *salt_buf = salts_buf + salt_idx;
u32 digests_cnt = salt_buf->digests_cnt;
for (u32 digest_idx = 0; digest_idx < digests_cnt; digest_idx++)
{
const u32 hashes_idx = salt_buf->digests_offset + digest_idx;
u32 *digests_shown = hashes->digests_shown;
if (digests_shown[hashes_idx] == 0) continue;
hash_t *hash = &hashes_buf[hashes_idx];
u8 *out_buf = potfile_ctx->out_buf;
out_buf[0] = 0;
ascii_digest (hashcat_ctx, (char *) out_buf, HCBUFSIZ_LARGE, salt_idx, digest_idx);
// user
unsigned char *username = NULL;
u32 user_len = 0;
if (hash->hash_info != NULL)
{
user_t *user = hash->hash_info->user;
if (user)
{
username = (unsigned char *) (user->user_name);
user_len = user->user_len;
username[user_len] = 0;
}
}
u8 *tmp_buf = potfile_ctx->tmp_buf;
tmp_buf[0] = 0;
// special case for collider modes: we do not use the $HEX[] format within the hash itself
// therefore we need to convert the $HEX[] password into hexadecimal (without "$HEX[" and "]")
bool is_collider_hex_password = false;
if ((hashconfig->hash_mode == 9710) || (hashconfig->hash_mode == 9810) || (hashconfig->hash_mode == 10410))
{
if (is_hexify ((u8 *) hash->pw_buf, hash->pw_len) == true)
{
is_collider_hex_password = true;
}
}
int tmp_len = 0;
if (is_collider_hex_password == true)
{
u8 pass_unhexified[HCBUFSIZ_TINY] = { 0 };
u32 pass_unhexified_len = 0;
pass_unhexified_len = exec_unhexify ((u8 *) hash->pw_buf, hash->pw_len, pass_unhexified, sizeof (pass_unhexified));
tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, pass_unhexified, pass_unhexified_len, 0, username, user_len, (char *) tmp_buf);
}
else
{
tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, (u8 *) hash->pw_buf, hash->pw_len, 0, username, user_len, (char *) tmp_buf);
}
EVENT_DATA (EVENT_POTFILE_HASH_SHOW, tmp_buf, tmp_len);
}
}
}
return 0;
}
static int monitor (hashcat_ctx_t *hashcat_ctx)
{
hashes_t *hashes = hashcat_ctx->hashes;
hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
bool runtime_check = false;
bool remove_check = false;
bool status_check = false;
bool restore_check = false;
bool hwmon_check = false;
bool performance_check = false;
const int sleep_time = 1;
const int temp_threshold = 1; // degrees celcius
const int fan_speed_min = 33; // in percentage
const int fan_speed_max = 100;
const double exec_low = 50.0; // in ms
const double util_low = 90.0; // in percent
if (user_options->runtime)
{
runtime_check = true;
}
if (restore_ctx->enabled == true)
{
restore_check = true;
}
if ((user_options->remove == true) && (hashes->hashlist_mode == HL_MODE_FILE))
{
remove_check = true;
}
if (user_options->status == true)
{
status_check = true;
}
if (hwmon_ctx->enabled == true)
{
hwmon_check = true;
}
if (hwmon_ctx->enabled == true)
{
performance_check = true; // this check simply requires hwmon to work
}
if ((runtime_check == false) && (remove_check == false) && (status_check == false) && (restore_check == false) && (hwmon_check == false) && (performance_check == false))
{
return 0;
}
// these variables are mainly used for fan control
int fan_speed_chgd[DEVICES_MAX];
memset (fan_speed_chgd, 0, sizeof (fan_speed_chgd));
// temperature controller "loopback" values
int temp_diff_old[DEVICES_MAX];
int temp_diff_sum[DEVICES_MAX];
memset (temp_diff_old, 0, sizeof (temp_diff_old));
memset (temp_diff_sum, 0, sizeof (temp_diff_sum));
// timer
hc_time_t last_temp_check_time;
hc_time (&last_temp_check_time);
u32 slowdown_warnings = 0;
u32 performance_warnings = 0;
u32 restore_left = user_options->restore_timer;
u32 remove_left = user_options->remove_timer;
u32 status_left = user_options->status_timer;
while (status_ctx->shutdown_inner == false)
{
sleep (sleep_time);
if (status_ctx->devices_status == STATUS_INIT) continue;
if (hwmon_check == true)
{
hc_thread_mutex_lock (status_ctx->mux_hwmon);
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
const int rc_throttle = hm_get_throttle_with_device_id (hashcat_ctx, device_id);
if (rc_throttle == -1) continue;
if (rc_throttle > 0)
{
slowdown_warnings++;
if (slowdown_warnings == 1) EVENT_DATA (EVENT_MONITOR_THROTTLE1, &device_id, sizeof (u32));
if (slowdown_warnings == 2) EVENT_DATA (EVENT_MONITOR_THROTTLE2, &device_id, sizeof (u32));
if (slowdown_warnings == 3) EVENT_DATA (EVENT_MONITOR_THROTTLE3, &device_id, sizeof (u32));
}
else
{
slowdown_warnings = 0;
}
}
hc_thread_mutex_unlock (status_ctx->mux_hwmon);
}
if (hwmon_check == true)
{
hc_thread_mutex_lock (status_ctx->mux_hwmon);
hc_time_t temp_check_time;
hc_time (&temp_check_time);
u32 Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
if (Ta == 0) Ta = 1;
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
if ((opencl_ctx->devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
const int temperature = hm_get_temperature_with_device_id (hashcat_ctx, device_id);
if (temperature > (int) user_options->gpu_temp_abort)
{
EVENT_DATA (EVENT_MONITOR_TEMP_ABORT, &device_id, sizeof (u32));
myabort (hashcat_ctx);
}
if (hwmon_ctx->hm_device[device_id].fanspeed_get_supported == false) continue;
if (hwmon_ctx->hm_device[device_id].fanspeed_set_supported == false) continue;
const u32 gpu_temp_retain = user_options->gpu_temp_retain;
if (gpu_temp_retain > 0)
{
int temp_cur = temperature;
int temp_diff_new = (int) gpu_temp_retain - temp_cur;
temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
// calculate Ta value (time difference in seconds between the last check and this check)
last_temp_check_time = temp_check_time;
float Kp = 1.6f;
float Ki = 0.001f;
float Kd = 10.0f;
// PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
if (abs (fan_diff_required) >= temp_threshold)
{
const int fan_speed_cur = hm_get_fanspeed_with_device_id (hashcat_ctx, device_id);
int fan_speed_level = fan_speed_cur;
if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
int fan_speed_new = fan_speed_level - fan_diff_required;
if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
if (fan_speed_new != fan_speed_cur)
{
int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
{
if (device_param->device_vendor_id == VENDOR_ID_AMD)
{
if (hwmon_ctx->hm_adl)
{
hm_set_fanspeed_with_device_id_adl (hashcat_ctx, device_id, fan_speed_new, 1);
}
if (hwmon_ctx->hm_sysfs)
{
hm_set_fanspeed_with_device_id_sysfs (hashcat_ctx, device_id, fan_speed_new);
}
}
else if (device_param->device_vendor_id == VENDOR_ID_NV)
{
if (hwmon_ctx->hm_nvapi)
{
hm_set_fanspeed_with_device_id_nvapi (hashcat_ctx, device_id, fan_speed_new, 1);
}
if (hwmon_ctx->hm_xnvctrl)
{
hm_set_fanspeed_with_device_id_xnvctrl (hashcat_ctx, device_id, fan_speed_new);
}
}
fan_speed_chgd[device_id] = 1;
}
temp_diff_old[device_id] = temp_diff_new;
}
}
}
}
hc_thread_mutex_unlock (status_ctx->mux_hwmon);
}
if (restore_check == true)
{
restore_left--;
if (restore_left == 0)
{
const int rc = cycle_restore (hashcat_ctx);
if (rc == -1) return -1;
restore_left = user_options->restore_timer;
}
}
if ((runtime_check == true) && (status_ctx->runtime_start > 0))
{
const int runtime_left = get_runtime_left (hashcat_ctx);
if (runtime_left <= 0)
{
EVENT_DATA (EVENT_MONITOR_RUNTIME_LIMIT, NULL, 0);
myabort_runtime (hashcat_ctx);
}
}
if (remove_check == true)
{
remove_left--;
if (remove_left == 0)
{
if (hashes->digests_saved != hashes->digests_done)
{
hashes->digests_saved = hashes->digests_done;
const int rc = save_hash (hashcat_ctx);
if (rc == -1) return -1;
}
remove_left = user_options->remove_timer;
}
}
if (status_check == true)
{
status_left--;
if (status_left == 0)
{
hc_thread_mutex_lock (status_ctx->mux_display);
EVENT_DATA (EVENT_MONITOR_STATUS_REFRESH, NULL, 0);
hc_thread_mutex_unlock (status_ctx->mux_display);
status_left = user_options->status_timer;
}
}
if (performance_check == true)
{
int exec_cnt = 0;
int util_cnt = 0;
double exec_total = 0;
double util_total = 0;
hc_thread_mutex_lock (status_ctx->mux_hwmon);
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
exec_cnt++;
const double exec = status_get_exec_msec_dev (hashcat_ctx, device_id);
exec_total += exec;
const int util = hm_get_utilization_with_device_id (hashcat_ctx, device_id);
if (util == -1) continue;
util_total += (double) util;
util_cnt++;
}
hc_thread_mutex_unlock (status_ctx->mux_hwmon);
double exec_avg = 0;
double util_avg = 0;
if (exec_cnt > 0) exec_avg = exec_total / exec_cnt;
if (util_cnt > 0) util_avg = util_total / util_cnt;
if ((exec_avg > 0) && (exec_avg < exec_low))
{
performance_warnings++;
if (performance_warnings == 10) EVENT_DATA (EVENT_MONITOR_PERFORMANCE_HINT, NULL, 0);
}
if ((util_avg > 0) && (util_avg < util_low))
{
performance_warnings++;
if (performance_warnings == 10) EVENT_DATA (EVENT_MONITOR_PERFORMANCE_HINT, NULL, 0);
}
}
}
// final round of save_hash
if (remove_check == true)
{
if (hashes->digests_saved != hashes->digests_done)
{
const int rc = save_hash (hashcat_ctx);
if (rc == -1) return -1;
}
}
// final round of cycle_restore
if (restore_check == true)
{
const int rc = cycle_restore (hashcat_ctx);
if (rc == -1) return -1;
}
return 0;
}
int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx)
{
bitmap_ctx_t *bitmap_ctx = hashcat_ctx->bitmap_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
user_options_t *user_options = hashcat_ctx->user_options;
bitmap_ctx->enabled = false;
if (user_options->example_hashes == 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->show == true) return 0;
if (user_options->usage == true) return 0;
if (user_options->version == true) return 0;
bitmap_ctx->enabled = true;
/**
* generate bitmap tables
*/
const u32 bitmap_shift1 = 5;
const u32 bitmap_shift2 = 13;
const u32 bitmap_min = user_options->bitmap_min;
const u32 bitmap_max = user_options->bitmap_max;
u32 *bitmap_s1_a = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s1_b = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s1_c = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s1_d = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s2_a = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s2_b = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s2_c = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 *bitmap_s2_d = (u32 *) hcmalloc ((1u << bitmap_max) * sizeof (u32));
u32 bitmap_bits;
u32 bitmap_nums;
u32 bitmap_mask;
u32 bitmap_size;
for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
{
bitmap_nums = 1u << bitmap_bits;
bitmap_mask = bitmap_nums - 1;
bitmap_size = bitmap_nums * sizeof (u32);
if ((hashes->digests_cnt & bitmap_mask) == hashes->digests_cnt) break;
if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == true) continue;
if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == true) continue;
break;
}
if (bitmap_bits == bitmap_max)
{
EVENT_DATA (EVENT_BITMAP_FINAL_OVERFLOW, NULL, 0);
}
bitmap_nums = 1u << bitmap_bits;
bitmap_mask = bitmap_nums - 1;
bitmap_size = bitmap_nums * sizeof (u32);
generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
if (hashconfig->st_hash != NULL)
{
selftest_to_bitmap (bitmap_shift1, (char *) hashes->st_digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d);
selftest_to_bitmap (bitmap_shift2, (char *) hashes->st_digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d);
}
bitmap_ctx->bitmap_bits = bitmap_bits;
bitmap_ctx->bitmap_nums = bitmap_nums;
bitmap_ctx->bitmap_size = bitmap_size;
bitmap_ctx->bitmap_mask = bitmap_mask;
bitmap_ctx->bitmap_shift1 = bitmap_shift1;
bitmap_ctx->bitmap_shift2 = bitmap_shift2;
bitmap_ctx->bitmap_s1_a = bitmap_s1_a;
bitmap_ctx->bitmap_s1_b = bitmap_s1_b;
bitmap_ctx->bitmap_s1_c = bitmap_s1_c;
bitmap_ctx->bitmap_s1_d = bitmap_s1_d;
bitmap_ctx->bitmap_s2_a = bitmap_s2_a;
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;
}
int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
user_options_t *user_options = hashcat_ctx->user_options;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
/**
* load hashes, part I: find input mode, count hashes
*/
const char *hashfile = hashes->hashfile;
const u32 hashlist_mode = hashes->hashlist_mode;
u32 hashlist_format = HLFMT_HASHCAT;
u64 hashes_avail = 0;
if ((user_options->benchmark == false) && (user_options->stdout_flag == false) && (user_options->keyspace == false))
{
if (hashlist_mode == HL_MODE_ARG)
{
if ((hashconfig->hash_mode == 2500) || (hashconfig->hash_mode == 2501))
{
struct stat st;
if (stat (hashes->hashfile, &st) == -1)
{
event_log_error (hashcat_ctx, "%s: %s", hashes->hashfile, strerror (errno));
return -1;
}
// 392 = old hccap_t size
if ((st.st_size % 392) == 0)
{
const int rc = check_old_hccap (hashes->hashfile);
if (rc == 1)
{
event_log_error (hashcat_ctx, "%s: Old hccap format detected! You need to update: https://hashcat.net/q/hccapx", hashes->hashfile);
return -1;
}
}
hashes_avail = st.st_size / sizeof (hccapx_t);
}
else if (hashconfig->hash_mode == 14600)
{
struct stat st;
if (stat (hashes->hashfile, &st) == -1)
{
event_log_error (hashcat_ctx, "%s: %s", hashes->hashfile, strerror (errno));
return -1;
}
hashes_avail = LUKS_NUMKEYS;
}
else
{
hashes_avail = 1;
}
}
else if (hashlist_mode == HL_MODE_FILE)
{
FILE *fp = NULL;
if ((fp = fopen (hashfile, "rb")) == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", hashfile, strerror (errno));
return -1;
}
EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_PRE, hashfile, strlen (hashfile));
hashes_avail = count_lines (fp);
EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_POST, hashfile, strlen (hashfile));
rewind (fp);
if (hashes_avail == 0)
{
event_log_error (hashcat_ctx, "hashfile is empty or corrupt.");
fclose (fp);
return -1;
}
hashlist_format = hlfmt_detect (hashcat_ctx, fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
if ((user_options->remove == true) && (hashlist_format != HLFMT_HASHCAT))
{
event_log_error (hashcat_ctx, "Use of --remove is not supported in native hashfile-format mode.");
fclose (fp);
return -1;
}
fclose (fp);
}
}
else
{
hashes_avail = 1;
}
if (hashconfig->hash_mode == 3000) hashes_avail *= 2;
hashes->hashlist_format = hashlist_format;
/**
* load hashes, part II: allocate required memory, set pointers
*/
hash_t *hashes_buf = (hash_t *) hccalloc (hashes_avail, sizeof (hash_t));
void *digests_buf = hccalloc (hashes_avail, hashconfig->dgst_size);
salt_t *salts_buf = NULL;
void *esalts_buf = NULL;
void *hook_salts_buf = NULL;
if ((user_options->username == true) || (hashconfig->opts_type & OPTS_TYPE_HASH_COPY) || (hashconfig->opts_type & OPTS_TYPE_HASH_SPLIT))
{
u32 hash_pos;
for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
{
hashinfo_t *hash_info = (hashinfo_t *) hcmalloc (sizeof (hashinfo_t));
hashes_buf[hash_pos].hash_info = hash_info;
if (user_options->username == true)
{
hash_info->user = (user_t *) hcmalloc (sizeof (user_t));
}
if (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)
{
if (user_options->benchmark == false)
{
hash_info->orighash = (char *) hcmalloc (256);
}
}
if (hashconfig->opts_type & OPTS_TYPE_HASH_SPLIT)
{
hash_info->split = (split_t *) hcmalloc (sizeof (split_t));
}
}
}
if (hashconfig->is_salted == true)
{
salts_buf = (salt_t *) hccalloc (hashes_avail, sizeof (salt_t));
if (hashconfig->esalt_size > 0)
{
esalts_buf = hccalloc (hashes_avail, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size > 0)
{
hook_salts_buf = (seven_zip_hook_salt_t *) hccalloc (hashes_avail, hashconfig->hook_salt_size);
}
}
else
{
salts_buf = (salt_t *) hccalloc (1, sizeof (salt_t));
}
for (u32 hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
{
hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * hashconfig->dgst_size);
if (hashconfig->is_salted == true)
{
hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
if (hashconfig->esalt_size > 0)
{
hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size > 0)
{
hashes_buf[hash_pos].hook_salt = ((char *) hook_salts_buf) + (hash_pos * hashconfig->hook_salt_size);
}
}
else
{
hashes_buf[hash_pos].salt = &salts_buf[0];
}
}
hashes->hashes_buf = hashes_buf;
hashes->digests_buf = digests_buf;
hashes->salts_buf = salts_buf;
hashes->esalts_buf = esalts_buf;
hashes->hook_salts_buf = hook_salts_buf;
/**
* load hashes, part III: parse hashes or generate them if benchmark
*/
u32 hashes_cnt = 0;
if (user_options->benchmark == true)
{
hashconfig_benchmark_defaults (hashcat_ctx, hashes_buf[0].salt, hashes_buf[0].esalt, hashes_buf[0].hook_salt);
hashes->hashfile = "-";
hashes_cnt = 1;
}
else if (user_options->example_hashes == true)
{
}
else if (user_options->keyspace == true)
{
}
else if (user_options->stdout_flag == true)
{
}
else if (user_options->opencl_info == true)
{
}
else
{
if (hashes_avail == 0)
{
// ???
}
else if (hashlist_mode == HL_MODE_ARG)
{
char *input_buf = user_options_extra->hc_hash;
size_t input_len = strlen (input_buf);
char *hash_buf = NULL;
size_t hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
bool hash_fmt_error = 0;
if (hash_len < 1) hash_fmt_error = 1;
if (hash_buf == NULL) hash_fmt_error = 1;
if (hash_fmt_error)
{
event_log_warning (hashcat_ctx, "Failed to parse hashes using the '%s' format.", strhlfmt (hashlist_format));
}
else
{
if (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)
{
hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted == true)
{
memset (hashes_buf[0].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[0].esalt, 0, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[0].hook_salt, 0, hashconfig->hook_salt_size);
}
int parser_status = PARSER_OK;
if ((hashconfig->hash_mode == 2500) || (hashconfig->hash_mode == 2501))
{
hashes->hashlist_mode = HL_MODE_FILE;
FILE *fp = fopen (hash_buf, "rb");
if (fp == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", hash_buf, strerror (errno));
return -1;
}
char *in = (char *) hcmalloc (sizeof (hccapx_t));
while (!feof (fp))
{
const size_t nread = hc_fread (in, sizeof (hccapx_t), 1, fp);
if (nread == 0) break;
if (hashes_avail == hashes_cnt)
{
event_log_warning (hashcat_ctx, "Hashfile '%s': File changed during runtime. Skipping new data.", hash_buf);
break;
}
if (hashconfig->is_salted == true)
{
memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[hashes_cnt].esalt, 0, hashconfig->esalt_size);
if ((user_options->hash_mode == 2500) || (user_options->hash_mode == 2501))
{
wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
if (user_options->hccapx_message_pair_chgd == true)
{
wpa->message_pair_chgd = (int) user_options->hccapx_message_pair_chgd;
wpa->message_pair = (u8) user_options->hccapx_message_pair;
}
wpa->nonce_error_corrections = user_options->nonce_error_corrections;
}
}
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[hashes_cnt].hook_salt, 0, hashconfig->hook_salt_size);
}
parser_status = hashconfig->parse_func ((u8 *) in, sizeof (hccapx_t), &hashes_buf[hashes_cnt], hashconfig);
if (parser_status != PARSER_OK)
{
event_log_warning (hashcat_ctx, "Hashfile '%s': %s", hash_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
}
hcfree (in);
fclose (fp);
}
else if (hashconfig->hash_mode == 3000)
{
if (hash_len == 32)
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_buf[hashes_cnt].hash_info->split->split_group = 0;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_LEFT;
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
parser_status = hashconfig->parse_func ((u8 *) hash_buf + 16, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_buf[hashes_cnt].hash_info->split->split_group = 0;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_RIGHT;
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
else
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_buf[hashes_cnt].hash_info->split->split_group = 0;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_NONE;
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
}
else if (hashconfig->hash_mode == 14600)
{
hashes->hashlist_mode = HL_MODE_FILE;
for (int keyslot_idx = 0; keyslot_idx < LUKS_NUMKEYS; keyslot_idx++)
{
parser_status = luks_parse_hash ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig, keyslot_idx);
if (parser_status != PARSER_OK)
{
if (parser_status != PARSER_LUKS_KEY_DISABLED)
{
event_log_warning (hashcat_ctx, "Hashfile '%s': %s", hash_buf, strparser (parser_status));
}
continue;
}
hashes_cnt++;
}
}
else
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
}
}
else if (hashlist_mode == HL_MODE_FILE)
{
FILE *fp;
if ((fp = fopen (hashfile, "rb")) == NULL)
{
event_log_error (hashcat_ctx, "%s: %s", hashfile, strerror (errno));
return -1;
}
u32 line_num = 0;
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
time_t prev = 0;
time_t now = 0;
while (!feof (fp))
{
line_num++;
const size_t line_len = fgetl (fp, line_buf);
if (line_len == 0) continue;
if (hashes_avail == hashes_cnt)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u: File changed during runtime. Skipping new data.", hashes->hashfile, line_num);
break;
}
char *hash_buf = NULL;
size_t hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
bool hash_fmt_error = 0;
if (hash_len < 1) hash_fmt_error = 1;
if (hash_buf == NULL) hash_fmt_error = 1;
if (hash_fmt_error)
{
event_log_warning (hashcat_ctx, "Failed to parse hashes using the '%s' format.", strhlfmt (hashlist_format));
continue;
}
if (user_options->username == true)
{
char *user_buf = NULL;
size_t user_len = 0;
hlfmt_user (hashcat_ctx, hashlist_format, line_buf, line_len, &user_buf, &user_len);
// special case:
// both hash_t need to have the username info if the pwdump format is used (i.e. we have 2 hashes for 3000, both with same user)
u32 hashes_per_user = 1;
if (hashconfig->hash_mode == 3000) // the following conditions should be true if (hashlist_format == HLFMT_PWDUMP)
{
if (hash_len == 32)
{
hashes_per_user = 2;
}
}
for (u32 i = 0; i < hashes_per_user; i++)
{
user_t **user = &hashes_buf[hashes_cnt + i].hash_info->user;
*user = (user_t *) hcmalloc (sizeof (user_t));
user_t *user_ptr = *user;
if (user_buf != NULL)
{
user_ptr->user_name = hcstrdup (user_buf);
}
else
{
user_ptr->user_name = hcstrdup ("");
}
user_ptr->user_len = (u32) user_len;
}
}
if (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)
{
hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted == true)
{
memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
}
if (hashconfig->esalt_size > 0)
{
memset (hashes_buf[hashes_cnt].esalt, 0, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size > 0)
{
memset (hashes_buf[hashes_cnt].hook_salt, 0, hashconfig->hook_salt_size);
}
if (hashconfig->hash_mode == 3000)
{
if (hash_len == 32)
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
char *tmp_line_buf;
hc_asprintf (&tmp_line_buf, "%s", line_buf);
compress_terminal_line_length (tmp_line_buf, 38, 32);
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
hcfree (tmp_line_buf);
continue;
}
hashes_buf[hashes_cnt].hash_info->split->split_group = line_num;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_LEFT;
hashes_cnt++;
parser_status = hashconfig->parse_func ((u8 *) hash_buf + 16, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
char *tmp_line_buf;
hc_asprintf (&tmp_line_buf, "%s", line_buf);
compress_terminal_line_length (tmp_line_buf, 38, 32);
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
hcfree (tmp_line_buf);
continue;
}
hashes_buf[hashes_cnt].hash_info->split->split_group = line_num;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_RIGHT;
hashes_cnt++;
}
else
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
char *tmp_line_buf;
hc_asprintf (&tmp_line_buf, "%s", line_buf);
compress_terminal_line_length (tmp_line_buf, 38, 32);
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
hcfree (tmp_line_buf);
continue;
}
hashes_buf[hashes_cnt].hash_info->split->split_group = line_num;
hashes_buf[hashes_cnt].hash_info->split->split_origin = SPLIT_ORIGIN_NONE;
hashes_cnt++;
}
}
else
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
char *tmp_line_buf;
hc_asprintf (&tmp_line_buf, "%s", line_buf);
compress_terminal_line_length (tmp_line_buf, 38, 32);
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
hcfree (tmp_line_buf);
continue;
}
hashes_cnt++;
}
time (&now);
if ((now - prev) == 0) continue;
time (&prev);
hashlist_parse_t hashlist_parse;
hashlist_parse.hashes_cnt = hashes_cnt;
hashlist_parse.hashes_avail = hashes_avail;
EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse_t));
}
hashlist_parse_t hashlist_parse;
hashlist_parse.hashes_cnt = hashes_cnt;
hashlist_parse.hashes_avail = hashes_avail;
EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse_t));
hcfree (line_buf);
fclose (fp);
}
}
hashes->hashes_cnt = hashes_cnt;
if (hashes_cnt)
{
EVENT (EVENT_HASHLIST_SORT_HASH_PRE);
if (hashconfig->is_salted == true)
{
hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig);
}
else
{
hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt, (void *) hashconfig);
}
EVENT (EVENT_HASHLIST_SORT_HASH_POST);
}
if (hashconfig->hash_mode == 3000)
{
// update split split_neighbor after sorting
// see https://github.com/hashcat/hashcat/issues/1034 for good examples for testing
for (u32 i = 0; i < hashes_cnt; i++)
{
split_t *split1 = hashes_buf[i].hash_info->split;
if (split1->split_origin != SPLIT_ORIGIN_LEFT) continue;
for (u32 j = 0; j < hashes_cnt; j++)
{
split_t *split2 = hashes_buf[j].hash_info->split;
if (split2->split_origin != SPLIT_ORIGIN_RIGHT) continue;
if (split1->split_group != split2->split_group) continue;
split1->split_neighbor = j;
split2->split_neighbor = i;
break;
}
}
}
return 0;
}
void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain)
{
debugfile_ctx_t *debugfile_ctx = hashcat_ctx->debugfile_ctx;
loopback_ctx_t *loopback_ctx = hashcat_ctx->loopback_ctx;
hashes_t *hashes = hashcat_ctx->hashes;
const u32 salt_pos = plain->salt_pos;
const u32 digest_pos = plain->digest_pos; // relative
// hash
u8 *out_buf = hashes->out_buf;
out_buf[0] = 0;
ascii_digest (hashcat_ctx, (char *) out_buf, HCBUFSIZ_LARGE, salt_pos, digest_pos);
// plain
u32 plain_buf[64] = { 0 };
u8 *plain_ptr = (u8 *) plain_buf;
int plain_len = 0;
build_plain (hashcat_ctx, device_param, plain, plain_buf, &plain_len);
// crackpos
u64 crackpos = 0;
build_crackpos (hashcat_ctx, device_param, plain, &crackpos);
// debug
u8 debug_rule_buf[RP_PASSWORD_SIZE] = { 0 };
int debug_rule_len = 0; // -1 error
u8 debug_plain_ptr[RP_PASSWORD_SIZE] = { 0 };
int debug_plain_len = 0;
build_debugdata (hashcat_ctx, device_param, plain, debug_rule_buf, &debug_rule_len, debug_plain_ptr, &debug_plain_len);
// no need for locking, we're in a mutex protected function
potfile_write_append (hashcat_ctx, (char *) 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 (hashcat_ctx);
u8 *tmp_buf = hashes->tmp_buf;
tmp_buf[0] = 0;
const int tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, plain_ptr, plain_len, crackpos, NULL, 0, (char *) tmp_buf);
outfile_write_close (hashcat_ctx);
EVENT_DATA (EVENT_CRACKER_HASH_CRACKED, tmp_buf, tmp_len);
// if enabled, update also the loopback file
if (loopback_ctx->fp != NULL)
{
loopback_write_append (hashcat_ctx, plain_ptr, plain_len);
}
// if enabled, update also the (rule) debug file
if (debugfile_ctx->fp != NULL)
{
// the next check implies that:
// - (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
// - debug_mode > 0
if ((debug_plain_len > 0) || (debug_rule_len > 0))
{
debugfile_write_append (hashcat_ctx, debug_rule_buf, debug_rule_len, plain_ptr, plain_len, debug_plain_ptr, debug_plain_len);
}
}
}
int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
user_options_t *user_options = hashcat_ctx->user_options;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
char *hash_or_file = user_options_extra->hc_hash;
/**
* load hashes, part I: find input mode, count hashes
*/
u32 hashlist_mode = 0;
u32 hashlist_format = HLFMT_HASHCAT;
u32 hashes_avail = 0;
if ((user_options->benchmark == false) && (user_options->stdout_flag == false))
{
hc_stat_t f;
hashlist_mode = (hc_stat (hash_or_file, &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
{
hashlist_mode = HL_MODE_ARG;
char *hashfile = hash_or_file;
hashes->hashfile = hashfile;
}
if (hashlist_mode == HL_MODE_ARG)
{
if (hashconfig->hash_mode == 2500)
{
hc_stat_t st;
if (hc_stat (hashes->hashfile, &st) == -1)
{
event_log_error (hashcat_ctx, "%s: %m", hashes->hashfile);
return -1;
}
hashes_avail = st.st_size / sizeof (hccap_t);
}
else
{
hashes_avail = 1;
}
}
else if (hashlist_mode == HL_MODE_FILE)
{
char *hashfile = hash_or_file;
hashes->hashfile = hashfile;
FILE *fp = NULL;
if ((fp = fopen (hashfile, "rb")) == NULL)
{
event_log_error (hashcat_ctx, "%s: %m", hashfile);
return -1;
}
EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_PRE, hashfile, strlen (hashfile));
hashes_avail = count_lines (fp);
EVENT_DATA (EVENT_HASHLIST_COUNT_LINES_POST, hashfile, strlen (hashfile));
rewind (fp);
if (hashes_avail == 0)
{
event_log_error (hashcat_ctx, "hashfile is empty or corrupt");
fclose (fp);
return -1;
}
hashlist_format = hlfmt_detect (hashcat_ctx, fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
if ((user_options->remove == 1) && (hashlist_format != HLFMT_HASHCAT))
{
event_log_error (hashcat_ctx, "remove not supported in native hashfile-format mode");
fclose (fp);
return -1;
}
fclose (fp);
}
}
else
{
hashlist_mode = HL_MODE_ARG;
hashes_avail = 1;
}
if (hashconfig->hash_mode == 3000) hashes_avail *= 2;
hashes->hashlist_mode = hashlist_mode;
hashes->hashlist_format = hashlist_format;
/**
* load hashes, part II: allocate required memory, set pointers
*/
hash_t *hashes_buf = NULL;
void *digests_buf = NULL;
salt_t *salts_buf = NULL;
void *esalts_buf = NULL;
hashes_buf = (hash_t *) hccalloc (hashes_avail, sizeof (hash_t));
digests_buf = (void *) hccalloc (hashes_avail, hashconfig->dgst_size);
if ((user_options->username == true) || (hashconfig->opts_type & OPTS_TYPE_HASH_COPY))
{
u32 hash_pos;
for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
{
hashinfo_t *hash_info = (hashinfo_t *) hcmalloc (sizeof (hashinfo_t));
hashes_buf[hash_pos].hash_info = hash_info;
if (user_options->username == true)
{
hash_info->user = (user_t*) hcmalloc (sizeof (user_t));
}
if (user_options->benchmark == true)
{
hash_info->orighash = (char *) hcmalloc (256);
}
}
}
if (hashconfig->is_salted)
{
salts_buf = (salt_t *) hccalloc (hashes_avail, sizeof (salt_t));
if (hashconfig->esalt_size)
{
esalts_buf = (void *) hccalloc (hashes_avail, hashconfig->esalt_size);
}
}
else
{
salts_buf = (salt_t *) hccalloc (1, sizeof (salt_t));
}
for (u32 hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
{
hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * hashconfig->dgst_size);
if (hashconfig->is_salted)
{
hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
if (hashconfig->esalt_size)
{
hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * hashconfig->esalt_size);
}
}
else
{
hashes_buf[hash_pos].salt = &salts_buf[0];
}
}
hashes->hashes_buf = hashes_buf;
hashes->digests_buf = digests_buf;
hashes->salts_buf = salts_buf;
hashes->esalts_buf = esalts_buf;
/**
* load hashes, part III: parse hashes or generate them if benchmark
*/
u32 hashes_cnt = 0;
if (user_options->benchmark == true)
{
hashconfig_benchmark_defaults (hashcat_ctx, hashes_buf[0].salt, hashes_buf[0].esalt);
hashes->hashfile = "-";
hashes_cnt = 1;
}
else if (user_options->keyspace == true)
{
}
else if (user_options->stdout_flag == true)
{
}
else if (user_options->opencl_info == true)
{
}
else
{
if (hashes_avail == 0)
{
// ???
}
else if (hashlist_mode == HL_MODE_ARG)
{
char *input_buf = hash_or_file;
u32 input_len = strlen (input_buf);
char *hash_buf = NULL;
int hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
bool hash_fmt_error = 0;
if (hash_len < 1) hash_fmt_error = 1;
if (hash_buf == NULL) hash_fmt_error = 1;
if (hash_fmt_error)
{
event_log_warning (hashcat_ctx, "Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
}
else
{
if (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)
{
hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted)
{
memset (hashes_buf[0].salt, 0, sizeof (salt_t));
}
int parser_status = PARSER_OK;
if (hashconfig->hash_mode == 2500)
{
if (hash_len == 0)
{
event_log_error (hashcat_ctx, "hccap file not specified");
return -1;
}
hashlist_mode = HL_MODE_FILE;
hashes->hashlist_mode = hashlist_mode;
FILE *fp = fopen (hash_buf, "rb");
if (fp == NULL)
{
event_log_error (hashcat_ctx, "%s: %m", hash_buf);
return -1;
}
if (hashes_avail < 1)
{
event_log_error (hashcat_ctx, "hccap file is empty or corrupt");
fclose (fp);
return -1;
}
char *in = (char *) hcmalloc (sizeof (hccap_t));
while (!feof (fp))
{
const int nread = fread (in, sizeof (hccap_t), 1, fp);
if (nread == 0) break;
if (hashes_avail == hashes_cnt)
{
event_log_warning (hashcat_ctx, "Hashfile '%s': File changed during runtime, skipping new data", hash_buf);
break;
}
parser_status = hashconfig->parse_func ((u8 *) in, sizeof (hccap_t), &hashes_buf[hashes_cnt], hashconfig);
if (parser_status != PARSER_OK)
{
event_log_warning (hashcat_ctx, "Hashfile '%s': %s", hash_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
}
hcfree (in);
fclose (fp);
}
else if (hashconfig->hash_mode == 3000)
{
if (hash_len == 32)
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
parser_status = hashconfig->parse_func ((u8 *) hash_buf + 16, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
else
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
}
else
{
parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK)
{
hashes_cnt++;
}
else
{
event_log_warning (hashcat_ctx, "Hash '%s': %s", input_buf, strparser (parser_status));
}
}
}
}
else if (hashlist_mode == HL_MODE_FILE)
{
char *hashfile = hashes->hashfile;
FILE *fp;
if ((fp = fopen (hashfile, "rb")) == NULL)
{
event_log_error (hashcat_ctx, "%s: %m", hashfile);
return -1;
}
u32 line_num = 0;
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
time_t prev = 0;
time_t now = 0;
while (!feof (fp))
{
line_num++;
int line_len = fgetl (fp, line_buf);
if (line_len == 0) continue;
if (hashes_avail == hashes_cnt)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u: File changed during runtime, skipping new data", hashes->hashfile, line_num);
break;
}
char *hash_buf = NULL;
int hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
bool hash_fmt_error = 0;
if (hash_len < 1) hash_fmt_error = 1;
if (hash_buf == NULL) hash_fmt_error = 1;
if (hash_fmt_error)
{
event_log_warning (hashcat_ctx, "failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
continue;
}
if (user_options->username == true)
{
char *user_buf = NULL;
int user_len = 0;
hlfmt_user (hashcat_ctx, hashlist_format, line_buf, line_len, &user_buf, &user_len);
user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
*user = (user_t *) hcmalloc (sizeof (user_t));
user_t *user_ptr = *user;
if (user_buf != NULL)
{
user_ptr->user_name = hcstrdup (user_buf);
}
else
{
user_ptr->user_name = hcstrdup ("");
}
user_ptr->user_len = user_len;
}
if (hashconfig->opts_type & OPTS_TYPE_HASH_COPY)
{
hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
hash_info_tmp->orighash = hcstrdup (hash_buf);
}
if (hashconfig->is_salted)
{
memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
}
if (hashconfig->hash_mode == 3000)
{
if (hash_len == 32)
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
parser_status = hashconfig->parse_func ((u8 *) hash_buf + 16, 16, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
}
else
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
}
}
else
{
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO)
{
event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
hashes_cnt++;
}
time (&now);
if ((now - prev) == 0) continue;
time (&prev);
hashlist_parse_t hashlist_parse;
hashlist_parse.hashes_cnt = hashes_cnt;
hashlist_parse.hashes_avail = hashes_avail;
EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse_t));
}
hashlist_parse_t hashlist_parse;
hashlist_parse.hashes_cnt = hashes_cnt;
hashlist_parse.hashes_avail = hashes_avail;
EVENT_DATA (EVENT_HASHLIST_PARSE_HASH, &hashlist_parse, sizeof (hashlist_parse_t));
hcfree (line_buf);
fclose (fp);
}
}
hashes->hashes_cnt = hashes_cnt;
if (hashes_cnt)
{
EVENT (EVENT_HASHLIST_SORT_HASH_PRE);
if (hashconfig->is_salted)
{
hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig);
}
else
{
hc_qsort_r (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt, (void *) hashconfig);
}
EVENT (EVENT_HASHLIST_SORT_HASH_POST);
}
return 0;
}
static int monitor (hashcat_ctx_t *hashcat_ctx)
{
hashes_t *hashes = hashcat_ctx->hashes;
hwmon_ctx_t *hwmon_ctx = hashcat_ctx->hwmon_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
bool runtime_check = false;
bool remove_check = false;
bool status_check = false;
bool restore_check = false;
bool hwmon_check = false;
bool performance_check = false;
const int sleep_time = 1;
const double exec_low = 50.0; // in ms
const double util_low = 90.0; // in percent
if (user_options->runtime)
{
runtime_check = true;
}
if (restore_ctx->enabled == true)
{
restore_check = true;
}
if ((user_options->remove == true) && (hashes->hashlist_mode == HL_MODE_FILE))
{
remove_check = true;
}
if (user_options->status == true)
{
status_check = true;
}
if (hwmon_ctx->enabled == true)
{
hwmon_check = true;
}
if (hwmon_ctx->enabled == true)
{
performance_check = true; // this check simply requires hwmon to work
}
if ((runtime_check == false) && (remove_check == false) && (status_check == false) && (restore_check == false) && (hwmon_check == false) && (performance_check == false))
{
return 0;
}
// timer
u32 slowdown_warnings = 0;
u32 performance_warnings = 0;
u32 restore_left = user_options->restore_timer;
u32 remove_left = user_options->remove_timer;
u32 status_left = user_options->status_timer;
while (status_ctx->shutdown_inner == false)
{
sleep (sleep_time);
if (status_ctx->devices_status == STATUS_INIT) continue;
if (hwmon_ctx->enabled == true)
{
hc_thread_mutex_lock (status_ctx->mux_hwmon);
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
if ((opencl_ctx->devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
const int temperature = hm_get_temperature_with_device_id (hashcat_ctx, device_id);
if (temperature > (int) user_options->hwmon_temp_abort)
{
EVENT_DATA (EVENT_MONITOR_TEMP_ABORT, &device_id, sizeof (u32));
myabort (hashcat_ctx);
}
}
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
const int rc_throttle = hm_get_throttle_with_device_id (hashcat_ctx, device_id);
if (rc_throttle == -1) continue;
if (rc_throttle > 0)
{
slowdown_warnings++;
if (slowdown_warnings == 1) EVENT_DATA (EVENT_MONITOR_THROTTLE1, &device_id, sizeof (u32));
if (slowdown_warnings == 2) EVENT_DATA (EVENT_MONITOR_THROTTLE2, &device_id, sizeof (u32));
if (slowdown_warnings == 3) EVENT_DATA (EVENT_MONITOR_THROTTLE3, &device_id, sizeof (u32));
}
else
{
if (slowdown_warnings > 0) slowdown_warnings--;
}
}
hc_thread_mutex_unlock (status_ctx->mux_hwmon);
}
if (restore_check == true)
{
restore_left--;
if (restore_left == 0)
{
const int rc = cycle_restore (hashcat_ctx);
if (rc == -1) return -1;
restore_left = user_options->restore_timer;
}
}
if ((runtime_check == true) && (status_ctx->runtime_start > 0))
{
const int runtime_left = get_runtime_left (hashcat_ctx);
if (runtime_left <= 0)
{
EVENT_DATA (EVENT_MONITOR_RUNTIME_LIMIT, NULL, 0);
myabort_runtime (hashcat_ctx);
}
}
if (remove_check == true)
{
remove_left--;
if (remove_left == 0)
{
if (hashes->digests_saved != hashes->digests_done)
{
hashes->digests_saved = hashes->digests_done;
const int rc = save_hash (hashcat_ctx);
if (rc == -1) return -1;
}
remove_left = user_options->remove_timer;
}
}
if (status_check == true)
{
status_left--;
if (status_left == 0)
{
hc_thread_mutex_lock (status_ctx->mux_display);
EVENT_DATA (EVENT_MONITOR_STATUS_REFRESH, NULL, 0);
hc_thread_mutex_unlock (status_ctx->mux_display);
status_left = user_options->status_timer;
}
}
if (performance_check == true)
{
int exec_cnt = 0;
int util_cnt = 0;
double exec_total = 0;
double util_total = 0;
hc_thread_mutex_lock (status_ctx->mux_hwmon);
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];
if (device_param->skipped == true) continue;
exec_cnt++;
const double exec = status_get_exec_msec_dev (hashcat_ctx, device_id);
exec_total += exec;
const int util = hm_get_utilization_with_device_id (hashcat_ctx, device_id);
if (util == -1) continue;
util_total += (double) util;
util_cnt++;
}
hc_thread_mutex_unlock (status_ctx->mux_hwmon);
double exec_avg = 0;
double util_avg = 0;
if (exec_cnt > 0) exec_avg = exec_total / exec_cnt;
if (util_cnt > 0) util_avg = util_total / util_cnt;
if ((exec_avg > 0) && (exec_avg < exec_low))
{
performance_warnings++;
if (performance_warnings == 10) EVENT_DATA (EVENT_MONITOR_PERFORMANCE_HINT, NULL, 0);
}
if ((util_avg > 0) && (util_avg < util_low))
{
performance_warnings++;
if (performance_warnings == 10) EVENT_DATA (EVENT_MONITOR_PERFORMANCE_HINT, NULL, 0);
}
}
// stdin read timeout check
// note: we skip the stdin timeout check if it was disabled with stdin_timeout_abort set to 0
if (user_options->stdin_timeout_abort != 0)
{
if (status_get_progress_done (hashcat_ctx) == 0)
{
if (status_ctx->stdin_read_timeout_cnt > 0)
{
if (status_ctx->stdin_read_timeout_cnt >= user_options->stdin_timeout_abort)
{
EVENT_DATA (EVENT_MONITOR_NOINPUT_ABORT, NULL, 0);
myabort (hashcat_ctx);
status_ctx->shutdown_inner = true;
break;
}
if ((status_ctx->stdin_read_timeout_cnt % STDIN_TIMEOUT_WARN) == 0)
{
EVENT_DATA (EVENT_MONITOR_NOINPUT_HINT, NULL, 0);
}
}
}
}
}
// final round of save_hash
if (remove_check == true)
{
if (hashes->digests_saved != hashes->digests_done)
{
const int rc = save_hash (hashcat_ctx);
if (rc == -1) return -1;
}
}
// final round of cycle_restore
if (restore_check == true)
{
const int rc = cycle_restore (hashcat_ctx);
if (rc == -1) return -1;
}
return 0;
}
