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; }