static void main_outerloop_finished (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len)
{
hashcat_user_t *hashcat_user = hashcat_ctx->hashcat_user;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
// wait for outer threads
status_ctx->shutdown_outer = true;
for (int thread_idx = 0; thread_idx < hashcat_user->outer_threads_cnt; thread_idx++)
{
hc_thread_wait (1, &hashcat_user->outer_threads[thread_idx]);
}
hcfree (hashcat_user->outer_threads);
hashcat_user->outer_threads_cnt = 0;
}
static int inner2_loop (hashcat_ctx_t *hashcat_ctx)
{
hashes_t *hashes = hashcat_ctx->hashes;
induct_ctx_t *induct_ctx = hashcat_ctx->induct_ctx;
logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_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_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
user_options_t *user_options = hashcat_ctx->user_options;
//status_ctx->run_main_level1 = true;
//status_ctx->run_main_level2 = true;
//status_ctx->run_main_level3 = true;
status_ctx->run_thread_level1 = true;
status_ctx->run_thread_level2 = true;
status_ctx->devices_status = STATUS_INIT;
logfile_generate_subid (hashcat_ctx);
logfile_sub_msg ("START");
status_progress_reset (hashcat_ctx);
status_ctx->msec_paused = 0;
status_ctx->words_off = 0;
status_ctx->words_cur = 0;
if (restore_ctx->rd)
{
restore_data_t *rd = restore_ctx->rd;
if (rd->words_cur > 0)
{
status_ctx->words_off = rd->words_cur;
status_ctx->words_cur = status_ctx->words_off;
rd->words_cur = 0;
// --restore always overrides --skip
user_options->skip = 0;
}
}
if (user_options->skip > 0)
{
status_ctx->words_off = user_options->skip;
status_ctx->words_cur = status_ctx->words_off;
user_options->skip = 0;
}
opencl_session_reset (hashcat_ctx);
cpt_ctx_reset (hashcat_ctx);
/**
* Update attack-mode specific stuff based on mask
*/
const int rc_mask_ctx_update_loop = mask_ctx_update_loop (hashcat_ctx);
if (rc_mask_ctx_update_loop == -1) return 0;
/**
* Update attack-mode specific stuff based on wordlist
*/
const int rc_straight_ctx_update_loop = straight_ctx_update_loop (hashcat_ctx);
if (rc_straight_ctx_update_loop == -1) return 0;
// words base
const u64 amplifier_cnt = user_options_extra_amplifier (hashcat_ctx);
status_ctx->words_base = status_ctx->words_cnt / amplifier_cnt;
EVENT (EVENT_CALCULATED_WORDS_BASE);
if (user_options->keyspace == true) return 0;
// restore stuff
if (status_ctx->words_off > status_ctx->words_base)
{
event_log_error (hashcat_ctx, "Restore value is greater than keyspace.");
return -1;
}
const u64 progress_restored = status_ctx->words_off * amplifier_cnt;
for (u32 i = 0; i < hashes->salts_cnt; i++)
{
status_ctx->words_progress_restored[i] = progress_restored;
}
/**
* limit kernel loops by the amplification count we have from:
* - straight_ctx, combinator_ctx or mask_ctx for fast hashes
* - hash iteration count for slow hashes
* this is required for autotune
*/
opencl_ctx_devices_kernel_loops (hashcat_ctx);
/**
* prepare thread buffers
*/
thread_param_t *threads_param = (thread_param_t *) hccalloc (opencl_ctx->devices_cnt, sizeof (thread_param_t));
hc_thread_t *c_threads = (hc_thread_t *) hccalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t));
/**
* create autotune threads
*/
EVENT (EVENT_AUTOTUNE_STARTING);
status_ctx->devices_status = STATUS_AUTOTUNE;
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
thread_param_t *thread_param = threads_param + device_id;
thread_param->hashcat_ctx = hashcat_ctx;
thread_param->tid = device_id;
hc_thread_create (c_threads[device_id], thread_autotune, thread_param);
}
hc_thread_wait (opencl_ctx->devices_cnt, c_threads);
EVENT (EVENT_AUTOTUNE_FINISHED);
/**
* autotune modified kernel_accel, which modifies opencl_ctx->kernel_power_all
*/
opencl_ctx_devices_update_power (hashcat_ctx);
/**
* Begin loopback recording
*/
if (user_options->loopback == true)
{
loopback_write_open (hashcat_ctx);
}
/**
* Prepare cracking stats
*/
hc_timer_set (&status_ctx->timer_running);
hc_time_t runtime_start;
hc_time (&runtime_start);
status_ctx->runtime_start = runtime_start;
/**
* create cracker threads
*/
EVENT (EVENT_CRACKER_STARTING);
status_ctx->devices_status = STATUS_RUNNING;
status_ctx->accessible = true;
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
thread_param_t *thread_param = threads_param + device_id;
thread_param->hashcat_ctx = hashcat_ctx;
thread_param->tid = device_id;
if (user_options_extra->wordlist_mode == WL_MODE_STDIN)
{
hc_thread_create (c_threads[device_id], thread_calc_stdin, thread_param);
}
else
{
hc_thread_create (c_threads[device_id], thread_calc, thread_param);
}
}
hc_thread_wait (opencl_ctx->devices_cnt, c_threads);
hcfree (c_threads);
hcfree (threads_param);
if ((status_ctx->devices_status == STATUS_RUNNING) && (status_ctx->checkpoint_shutdown == true))
{
myabort_checkpoint (hashcat_ctx);
}
if ((status_ctx->devices_status != STATUS_CRACKED)
&& (status_ctx->devices_status != STATUS_ABORTED)
&& (status_ctx->devices_status != STATUS_ABORTED_CHECKPOINT)
&& (status_ctx->devices_status != STATUS_ABORTED_RUNTIME)
&& (status_ctx->devices_status != STATUS_QUIT)
&& (status_ctx->devices_status != STATUS_BYPASS))
{
status_ctx->devices_status = STATUS_EXHAUSTED;
}
// update some timer
hc_time_t runtime_stop;
hc_time (&runtime_stop);
status_ctx->runtime_stop = runtime_stop;
logfile_sub_uint (runtime_start);
logfile_sub_uint (runtime_stop);
if (hashcat_get_status (hashcat_ctx, status_ctx->hashcat_status_final) == -1)
{
fprintf (stderr, "Initialization problem: the hashcat status monitoring function returned an unexpected value\n");
}
status_ctx->accessible = false;
EVENT (EVENT_CRACKER_FINISHED);
// mark sub logfile
logfile_sub_var_uint ("status-after-work", status_ctx->devices_status);
logfile_sub_msg ("STOP");
// stop loopback recording
if (user_options->loopback == true)
{
loopback_write_close (hashcat_ctx);
}
// New induction folder check, which is a controlled recursion
if (induct_ctx->induction_dictionaries_cnt == 0)
{
induct_ctx_scan (hashcat_ctx);
while (induct_ctx->induction_dictionaries_cnt)
{
for (induct_ctx->induction_dictionaries_pos = 0; induct_ctx->induction_dictionaries_pos < induct_ctx->induction_dictionaries_cnt; induct_ctx->induction_dictionaries_pos++)
{
if (status_ctx->devices_status == STATUS_EXHAUSTED)
{
const int rc_inner2_loop = inner2_loop (hashcat_ctx);
if (rc_inner2_loop == -1) myabort (hashcat_ctx);
if (status_ctx->run_main_level3 == false) break;
}
unlink (induct_ctx->induction_dictionaries[induct_ctx->induction_dictionaries_pos]);
}
hcfree (induct_ctx->induction_dictionaries);
induct_ctx_scan (hashcat_ctx);
}
}
return 0;
}
static int outer_loop (hashcat_ctx_t *hashcat_ctx)
{
hashes_t *hashes = hashcat_ctx->hashes;
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;
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;
user_options_t *user_options = hashcat_ctx->user_options;
status_ctx->devices_status = STATUS_INIT;
//status_ctx->run_main_level1 = true;
status_ctx->run_main_level2 = true;
status_ctx->run_main_level3 = true;
status_ctx->run_thread_level1 = true;
status_ctx->run_thread_level2 = true;
/**
* setup variables and buffers depending on hash_mode
*/
const int rc_hashconfig = hashconfig_init (hashcat_ctx);
if (rc_hashconfig == -1)
{
event_log_error (hashcat_ctx, "Unknown hash-type '%u' selected.", user_options->hash_mode);
return -1;
}
/**
* load hashes, stage 1
*/
const int rc_hashes_init_stage1 = hashes_init_stage1 (hashcat_ctx);
if (rc_hashes_init_stage1 == -1) return -1;
if ((user_options->keyspace == false) && (user_options->stdout_flag == false))
{
if (hashes->hashes_cnt == 0)
{
event_log_error (hashcat_ctx, "No hashes loaded.");
return -1;
}
}
/**
* load hashes, stage 2, remove duplicates, build base structure
*/
hashes->hashes_cnt_orig = hashes->hashes_cnt;
const int rc_hashes_init_stage2 = hashes_init_stage2 (hashcat_ctx);
if (rc_hashes_init_stage2 == -1) return -1;
/**
* potfile removes
*/
if (user_options->potfile_disable == false)
{
EVENT (EVENT_POTFILE_REMOVE_PARSE_PRE);
if (user_options->loopback == true)
{
loopback_write_open (hashcat_ctx);
}
potfile_remove_parse (hashcat_ctx);
if (user_options->loopback == true)
{
loopback_write_close (hashcat_ctx);
}
EVENT (EVENT_POTFILE_REMOVE_PARSE_POST);
}
/**
* load hashes, stage 3, update cracked results from potfile
*/
const int rc_hashes_init_stage3 = hashes_init_stage3 (hashcat_ctx);
if (rc_hashes_init_stage3 == -1) return -1;
/**
* potfile show/left handling
*/
if (user_options->show == true)
{
outfile_write_open (hashcat_ctx);
const int rc = potfile_handle_show (hashcat_ctx);
if (rc == -1) return -1;
outfile_write_close (hashcat_ctx);
return 0;
}
else if (user_options->left == true)
{
outfile_write_open (hashcat_ctx);
const int rc = potfile_handle_left (hashcat_ctx);
if (rc == -1) return -1;
outfile_write_close (hashcat_ctx);
return 0;
}
/**
* maybe all hashes were cracked, we can exit here
*/
if (status_ctx->devices_status == STATUS_CRACKED)
{
if ((user_options->remove == true) && (hashes->hashlist_mode == HL_MODE_FILE))
{
if (hashes->digests_saved != hashes->digests_done)
{
const int rc = save_hash (hashcat_ctx);
if (rc == -1) return -1;
}
}
EVENT (EVENT_POTFILE_ALL_CRACKED);
return 0;
}
/**
* load hashes, stage 4, automatic Optimizers
*/
const int rc_hashes_init_stage4 = hashes_init_stage4 (hashcat_ctx);
if (rc_hashes_init_stage4 == -1) return -1;
/**
* load hashes, selftest
*/
const int rc_hashes_init_selftest = hashes_init_selftest (hashcat_ctx);
if (rc_hashes_init_selftest == -1) return -1;
/**
* Done loading hashes, log results
*/
hashes_logger (hashcat_ctx);
/**
* bitmaps
*/
EVENT (EVENT_BITMAP_INIT_PRE);
const int rc_bitmap_init = bitmap_ctx_init (hashcat_ctx);
if (rc_bitmap_init == -1) return -1;
EVENT (EVENT_BITMAP_INIT_POST);
/**
* cracks-per-time allocate buffer
*/
cpt_ctx_init (hashcat_ctx);
/**
* Wordlist allocate buffer
*/
const int rc_wl_data_init = wl_data_init (hashcat_ctx);
if (rc_wl_data_init == -1) return -1;
/**
* straight mode init
*/
const int rc_straight_init = straight_ctx_init (hashcat_ctx);
if (rc_straight_init == -1) return -1;
/**
* straight mode init
*/
const int rc_combinator_init = combinator_ctx_init (hashcat_ctx);
if (rc_combinator_init == -1) return -1;
/**
* charsets : keep them together for more easy maintainnce
*/
const int rc_mask_init = mask_ctx_init (hashcat_ctx);
if (rc_mask_init == -1) return -1;
/**
* prevent the user from using --skip/--limit together with maskfile and/or multiple word lists
*/
if (user_options->skip != 0 || user_options->limit != 0)
{
if ((mask_ctx->masks_cnt > 1) || (straight_ctx->dicts_cnt > 1))
{
event_log_error (hashcat_ctx, "Use of --skip/--limit is not supported with --increment or mask files.");
return -1;
}
}
/**
* prevent the user from using --keyspace together with maskfile and/or multiple word lists
*/
if (user_options->keyspace == true)
{
if ((mask_ctx->masks_cnt > 1) || (straight_ctx->dicts_cnt > 1))
{
event_log_error (hashcat_ctx, "Use of --keyspace is not supported with --increment or mask files.");
return -1;
}
}
/**
* status progress init; needs hashes that's why we have to do it here and separate from status_ctx_init
*/
const int rc_status_init = status_progress_init (hashcat_ctx);
if (rc_status_init == -1) return -1;
/**
* main screen
*/
EVENT (EVENT_OUTERLOOP_MAINSCREEN);
/**
* Tell user about cracked hashes by potfile
*/
EVENT (EVENT_POTFILE_NUM_CRACKED);
/**
* inform the user
*/
EVENT (EVENT_OPENCL_SESSION_PRE);
const int rc_session_begin = opencl_session_begin (hashcat_ctx);
if (rc_session_begin == -1) return -1;
EVENT (EVENT_OPENCL_SESSION_POST);
/**
* create self-test threads
*/
EVENT (EVENT_SELFTEST_STARTING);
thread_param_t *threads_param = (thread_param_t *) hccalloc (opencl_ctx->devices_cnt, sizeof (thread_param_t));
hc_thread_t *selftest_threads = (hc_thread_t *) hccalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t));
status_ctx->devices_status = STATUS_SELFTEST;
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{
thread_param_t *thread_param = threads_param + device_id;
thread_param->hashcat_ctx = hashcat_ctx;
thread_param->tid = device_id;
hc_thread_create (selftest_threads[device_id], thread_selftest, thread_param);
}
hc_thread_wait (opencl_ctx->devices_cnt, selftest_threads);
hcfree (threads_param);
hcfree (selftest_threads);
status_ctx->devices_status = STATUS_INIT;
EVENT (EVENT_SELFTEST_FINISHED);
/**
* (old) weak hash check is the first to write to potfile, so open it for writing from here
* the weak hash check was removed maybe we can move this more to the bottom now
*/
const int rc_potfile_write = potfile_write_open (hashcat_ctx);
if (rc_potfile_write == -1) return -1;
/**
* status and monitor threads
*/
int inner_threads_cnt = 0;
hc_thread_t *inner_threads = (hc_thread_t *) hccalloc (10, sizeof (hc_thread_t));
status_ctx->shutdown_inner = false;
/**
* Outfile remove
*/
if (user_options->keyspace == false && user_options->stdout_flag == false && user_options->speed_only == false)
{
hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, hashcat_ctx);
inner_threads_cnt++;
if (outcheck_ctx->enabled == true)
{
hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, hashcat_ctx);
inner_threads_cnt++;
}
}
// main call
if (restore_ctx->rd)
{
restore_data_t *rd = restore_ctx->rd;
if (rd->masks_pos > 0)
{
mask_ctx->masks_pos = rd->masks_pos;
rd->masks_pos = 0;
}
}
EVENT (EVENT_INNERLOOP1_STARTING);
if (mask_ctx->masks_cnt)
{
for (u32 masks_pos = mask_ctx->masks_pos; masks_pos < mask_ctx->masks_cnt; masks_pos++)
{
mask_ctx->masks_pos = masks_pos;
const int rc_inner1_loop = inner1_loop (hashcat_ctx);
if (rc_inner1_loop == -1) myabort (hashcat_ctx);
if (status_ctx->run_main_level2 == false) break;
}
if (mask_ctx->masks_pos + 1 == mask_ctx->masks_cnt) mask_ctx->masks_pos = 0;
}
else
{
const int rc_inner1_loop = inner1_loop (hashcat_ctx);
if (rc_inner1_loop == -1) myabort (hashcat_ctx);
}
// wait for inner threads
status_ctx->shutdown_inner = true;
for (int thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
{
hc_thread_wait (1, &inner_threads[thread_idx]);
}
hcfree (inner_threads);
EVENT (EVENT_INNERLOOP1_FINISHED);
// finalize potfile
potfile_write_close (hashcat_ctx);
// finalize opencl session
opencl_session_destroy (hashcat_ctx);
// clean up
bitmap_ctx_destroy (hashcat_ctx);
combinator_ctx_destroy (hashcat_ctx);
cpt_ctx_destroy (hashcat_ctx);
hashconfig_destroy (hashcat_ctx);
hashes_destroy (hashcat_ctx);
mask_ctx_destroy (hashcat_ctx);
status_progress_destroy (hashcat_ctx);
straight_ctx_destroy (hashcat_ctx);
wl_data_destroy (hashcat_ctx);
return 0;
}
