int SuspendThreads (hashcat_ctx_t *hashcat_ctx) { status_ctx_t *status_ctx = hashcat_ctx->status_ctx; if (status_ctx->devices_status != STATUS_RUNNING) return -1; hc_timer_set (&status_ctx->timer_paused); status_ctx->devices_status = STATUS_PAUSED; return 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; }