/** * Author......: See docs/credits.txt * License.....: MIT */ #include "common.h" // basic tools #include "types.h" #include "folder.h" #include "memory.h" #include "shared.h" #include "thread.h" #include "timer.h" // features #include "affinity.h" #include "autotune.h" #include "benchmark.h" #include "bitmap.h" #include "combinator.h" #include "cpt.h" #include "debugfile.h" #include "dictstat.h" #include "dispatch.h" #include "event.h" #include "hashes.h" #include "hwmon.h" #include "hlfmt.h" #include "induct.h" #include "interface.h" #include "logfile.h" #include "loopback.h" #include "monitor.h" #include "mpsp.h" #include "backend.h" #include "outfile_check.h" #include "outfile.h" #include "pidfile.h" #include "potfile.h" #include "restore.h" #include "selftest.h" #include "status.h" #include "straight.h" #include "tuningdb.h" #include "user_options.h" #include "wordlist.h" #include "hashcat.h" #include "usage.h" #ifdef WITH_BRAIN #include "brain.h" #endif // inner2_loop iterates through wordlists, then calls kernel execution 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; backend_ctx_t *backend_ctx = hashcat_ctx->backend_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->restore_execute == true) { restore_ctx->restore_execute = false; restore_data_t *rd = restore_ctx->rd; status_ctx->words_off = rd->words_cur; status_ctx->words_cur = status_ctx->words_off; // --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; } backend_session_reset (hashcat_ctx); cpt_ctx_reset (hashcat_ctx); /** * Update attack-mode specific stuff based on mask */ if (mask_ctx_update_loop (hashcat_ctx) == -1) return 0; /** * Update attack-mode specific stuff based on wordlist */ if (straight_ctx_update_loop (hashcat_ctx) == -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) { status_ctx->devices_status = STATUS_RUNNING; 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; } if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { const u64 progress_restored = 1 * amplifier_cnt; for (u32 i = 0; i < status_ctx->words_off; i++) { status_ctx->words_progress_restored[i] = progress_restored; } } else { 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; } } #ifdef WITH_BRAIN if (user_options->brain_client == true) { user_options->brain_attack = brain_compute_attack (hashcat_ctx); } #endif /** * 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 */ backend_ctx_devices_kernel_loops (hashcat_ctx); /** * prepare thread buffers */ thread_param_t *threads_param = (thread_param_t *) hccalloc (backend_ctx->backend_devices_cnt, sizeof (thread_param_t)); hc_thread_t *c_threads = (hc_thread_t *) hccalloc (backend_ctx->backend_devices_cnt, sizeof (hc_thread_t)); /** * create autotune threads */ EVENT (EVENT_AUTOTUNE_STARTING); status_ctx->devices_status = STATUS_AUTOTUNE; for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { thread_param_t *thread_param = threads_param + backend_devices_idx; thread_param->hashcat_ctx = hashcat_ctx; thread_param->tid = backend_devices_idx; hc_thread_create (c_threads[backend_devices_idx], thread_autotune, thread_param); } hc_thread_wait (backend_ctx->backend_devices_cnt, c_threads); // check for any autotune failures // by default, skipping device on error // using --force, accel/loops/threads min values are used instead of skipping int at_err = 0; for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { if (backend_ctx->enabled == false) continue; hc_device_param_t *device_param = backend_ctx->devices_param + backend_devices_idx; if (device_param->skipped == true) continue; if (device_param->skipped_warning == true) continue; if (device_param->at_status == AT_STATUS_FAILED) { at_err++; if (user_options->force == false) { event_log_warning (hashcat_ctx, "* Device #%u: skipped, due to kernel autotune failure (%d).", device_param->device_id + 1, device_param->at_rc); device_param->skipped = true; // update counters if (device_param->is_hip == true) backend_ctx->hip_devices_active--; if (device_param->is_cuda == true) backend_ctx->cuda_devices_active--; if (device_param->is_opencl == true) backend_ctx->opencl_devices_active--; backend_ctx->backend_devices_active--; } else { event_log_warning (hashcat_ctx, "* Device #%u: detected kernel autotune failure (%d), min values will be used", device_param->device_id + 1, device_param->at_rc); } } } if (at_err > 0) { event_log_warning (hashcat_ctx, NULL); if (user_options->force == false) { // if all enabled devices fail, abort session if (backend_ctx->backend_devices_active <= 0) { event_log_error (hashcat_ctx, "Aborting session due to kernel autotune failures, for all active devices."); event_log_warning (hashcat_ctx, "You can use --force to override this, but do not report related errors."); event_log_warning (hashcat_ctx, NULL); return -10; } } } EVENT (EVENT_AUTOTUNE_FINISHED); /** * find same backend devices and equal results */ backend_ctx_devices_sync_tuning (hashcat_ctx); /** * autotune modified kernel_accel, which modifies backend_ctx->kernel_power_all */ backend_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); time_t runtime_start; 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 (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { thread_param_t *thread_param = threads_param + backend_devices_idx; thread_param->hashcat_ctx = hashcat_ctx; thread_param->tid = backend_devices_idx; if (user_options_extra->wordlist_mode == WL_MODE_STDIN) { hc_thread_create (c_threads[backend_devices_idx], thread_calc_stdin, thread_param); } else { hc_thread_create (c_threads[backend_devices_idx], thread_calc, thread_param); } } hc_thread_wait (backend_ctx->backend_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_RUNNING) && (status_ctx->finish_shutdown == true)) { myabort_finish (hashcat_ctx); } if ((status_ctx->devices_status != STATUS_CRACKED) && (status_ctx->devices_status != STATUS_ERROR) && (status_ctx->devices_status != STATUS_ABORTED) && (status_ctx->devices_status != STATUS_ABORTED_CHECKPOINT) && (status_ctx->devices_status != STATUS_ABORTED_FINISH) && (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; } if (status_ctx->devices_status == STATUS_EXHAUSTED) { // the options speed-only and progress-only cause hashcat to abort quickly. // therefore, they will end up (if no other error occured) as STATUS_EXHAUSTED. // however, that can create confusion in hashcats RC, because exhausted translates to RC = 1. // but then having RC = 1 does not match our expection if we use for speed-only and progress-only. // to get hashcat to return RC = 0 we have to set it to CRACKED or BYPASS // note: other options like --show, --left, --benchmark, --keyspace, --backend-info, etc. // not not reach this section of the code, they've returned already with rc 0. if ((user_options->speed_only == true) || (user_options->progress_only == true)) { status_ctx->devices_status = STATUS_BYPASS; } } // update some timer time_t runtime_stop; 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) { if (inner2_loop (hashcat_ctx) == -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; } // inner1_loop iterates through masks, then calls inner2_loop static int inner1_loop (hashcat_ctx_t *hashcat_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; //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; /** * loop through wordlists */ EVENT (EVENT_INNERLOOP2_STARTING); if (restore_ctx->rd) { restore_data_t *rd = restore_ctx->rd; if (rd->dicts_pos > 0) { straight_ctx->dicts_pos = rd->dicts_pos; rd->dicts_pos = 0; } } if (straight_ctx->dicts_cnt) { for (u32 dicts_pos = straight_ctx->dicts_pos; dicts_pos < straight_ctx->dicts_cnt; dicts_pos++) { straight_ctx->dicts_pos = dicts_pos; if (inner2_loop (hashcat_ctx) == -1) myabort (hashcat_ctx); if (status_ctx->run_main_level3 == false) break; } if (status_ctx->run_main_level3 == true) { if (straight_ctx->dicts_pos + 1 == straight_ctx->dicts_cnt) straight_ctx->dicts_pos = 0; } } else { if (inner2_loop (hashcat_ctx) == -1) myabort (hashcat_ctx); } EVENT (EVENT_INNERLOOP2_FINISHED); return 0; } // outer_loop iterates through hash_modes (in benchmark mode) // also initializes stuff that depend on hash mode static int outer_loop (hashcat_ctx_t *hashcat_ctx) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashes_t *hashes = hashcat_ctx->hashes; mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; module_ctx_t *module_ctx = hashcat_ctx->module_ctx; backend_ctx_t *backend_ctx = hashcat_ctx->backend_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; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; 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 */ EVENT (EVENT_HASHCONFIG_PRE); if (hashconfig_init (hashcat_ctx) == -1) { event_log_error (hashcat_ctx, "Invalid hash-mode '%u' selected.", user_options->hash_mode); return -1; } EVENT (EVENT_HASHCONFIG_POST); /** * deprecated notice */ if (module_ctx->module_deprecated_notice != MODULE_DEFAULT) { if (user_options->deprecated_check_disable == false) { if ((user_options->show == true) || (user_options->left == true)) { const char *module_deprecated_notice = module_ctx->module_deprecated_notice (hashconfig, user_options, user_options_extra); event_log_warning (hashcat_ctx, "%s", module_deprecated_notice); event_log_warning (hashcat_ctx, NULL); } else if (user_options->benchmark == true) { if (user_options->hash_mode_chgd == true) { const char *module_deprecated_notice = module_ctx->module_deprecated_notice (hashconfig, user_options, user_options_extra); event_log_warning (hashcat_ctx, "%s", module_deprecated_notice); event_log_warning (hashcat_ctx, NULL); } else { return 0; } } else { const char *module_deprecated_notice = module_ctx->module_deprecated_notice (hashconfig, user_options, user_options_extra); event_log_error (hashcat_ctx, "%s", module_deprecated_notice); return 0; } } } /** * generate hashlist filename for later use */ if (hashes_init_filename (hashcat_ctx) == -1) return -1; /** * load hashes, stage 1 */ if (hashes_init_stage1 (hashcat_ctx) == -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; if (hashes_init_stage2 (hashcat_ctx) == -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); } /** * zero hash removes */ if (hashes_init_zerohash (hashcat_ctx) == -1) return -1; /** * load hashes, stage 3, update cracked results from potfile */ if (hashes_init_stage3 (hashcat_ctx) == -1) return -1; /** * potfile show/left handling */ if (user_options->show == true) { status_ctx->devices_status = STATUS_RUNNING; outfile_write_open (hashcat_ctx); if (potfile_handle_show (hashcat_ctx) == -1) return -1; outfile_write_close (hashcat_ctx); return 0; } if (user_options->left == true) { status_ctx->devices_status = STATUS_RUNNING; outfile_write_open (hashcat_ctx); if (potfile_handle_left (hashcat_ctx) == -1) return -1; outfile_write_close (hashcat_ctx); return 0; } /** * check global hash count in case module developer sets a them to a specific limit */ if (hashes->digests_cnt < hashconfig->hashes_count_min) { event_log_error (hashcat_ctx, "Not enough hashes loaded - minimum is %u for this hash-mode.", hashconfig->hashes_count_min); return -1; } if (hashes->digests_cnt > hashconfig->hashes_count_max) { event_log_error (hashcat_ctx, "Too many hashes loaded - maximum is %u for this hash-mode.", hashconfig->hashes_count_max); return -1; } /** * 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_PLAIN) || (hashes->hashlist_mode == HL_MODE_FILE_BINARY))) { 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 */ if (hashes_init_stage4 (hashcat_ctx) == -1) return -1; /** * load hashes, selftest */ if (hashes_init_selftest (hashcat_ctx) == -1) return -1; /** * load hashes, benchmark */ if (hashes_init_benchmark (hashcat_ctx) == -1) return -1; /** * Done loading hashes, log results */ hashes_logger (hashcat_ctx); /** * bitmaps */ EVENT (EVENT_BITMAP_INIT_PRE); if (bitmap_ctx_init (hashcat_ctx) == -1) return -1; EVENT (EVENT_BITMAP_INIT_POST); /** * cracks-per-time allocate buffer */ cpt_ctx_init (hashcat_ctx); /** * Wordlist allocate buffer */ if (wl_data_init (hashcat_ctx) == -1) return -1; /** * straight mode init */ if (straight_ctx_init (hashcat_ctx) == -1) return -1; /** * straight mode init */ if (combinator_ctx_init (hashcat_ctx) == -1) return -1; /** * charsets : keep them together for more easy maintainnce */ if (mask_ctx_init (hashcat_ctx) == -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 */ if (status_progress_init (hashcat_ctx) == -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_BACKEND_SESSION_PRE); if (backend_session_begin (hashcat_ctx) == -1) { if (user_options->benchmark == true) { if (user_options->hash_mode_chgd == false) { // finalize backend session backend_session_destroy (hashcat_ctx); // clean up #ifdef WITH_BRAIN brain_ctx_destroy (hashcat_ctx); #endif 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; } } return -1; } EVENT (EVENT_BACKEND_SESSION_POST); /** * create self-test threads */ if ((hashconfig->opts_type & OPTS_TYPE_SELF_TEST_DISABLE) == 0) { EVENT (EVENT_SELFTEST_STARTING); thread_param_t *threads_param = (thread_param_t *) hccalloc (backend_ctx->backend_devices_cnt, sizeof (thread_param_t)); hc_thread_t *selftest_threads = (hc_thread_t *) hccalloc (backend_ctx->backend_devices_cnt, sizeof (hc_thread_t)); status_ctx->devices_status = STATUS_SELFTEST; for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { thread_param_t *thread_param = threads_param + backend_devices_idx; thread_param->hashcat_ctx = hashcat_ctx; thread_param->tid = backend_devices_idx; hc_thread_create (selftest_threads[backend_devices_idx], thread_selftest, thread_param); } hc_thread_wait (backend_ctx->backend_devices_cnt, selftest_threads); hcfree (threads_param); hcfree (selftest_threads); // check for any selftest failures for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { if (backend_ctx->enabled == false) continue; hc_device_param_t *device_param = backend_ctx->devices_param + backend_devices_idx; if (device_param->skipped == true) continue; if (device_param->st_status == ST_STATUS_FAILED) { event_log_error (hashcat_ctx, "Aborting session due to kernel self-test failure."); event_log_warning (hashcat_ctx, "You can use --self-test-disable to override, but do not report related errors."); event_log_warning (hashcat_ctx, NULL); return -1; } } 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 */ if (potfile_write_open (hashcat_ctx) == -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; if (inner1_loop (hashcat_ctx) == -1) myabort (hashcat_ctx); if (status_ctx->run_main_level2 == false) break; } if (status_ctx->run_main_level2 == true) { if (mask_ctx->masks_pos + 1 == mask_ctx->masks_cnt) mask_ctx->masks_pos = 0; } } else { if (inner1_loop (hashcat_ctx) == -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 backend session backend_session_destroy (hashcat_ctx); // clean up #ifdef WITH_BRAIN brain_ctx_destroy (hashcat_ctx); #endif 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; } static void event_stub (MAYBE_UNUSED const u32 id, MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const void *buf, MAYBE_UNUSED const size_t len) { } int hashcat_init (hashcat_ctx_t *hashcat_ctx, void (*event) (const u32, struct hashcat_ctx *, const void *, const size_t)) { if (event == NULL) { hashcat_ctx->event = event_stub; } else { hashcat_ctx->event = event; } hashcat_ctx->brain_ctx = (brain_ctx_t *) hcmalloc (sizeof (brain_ctx_t)); hashcat_ctx->bitmap_ctx = (bitmap_ctx_t *) hcmalloc (sizeof (bitmap_ctx_t)); hashcat_ctx->combinator_ctx = (combinator_ctx_t *) hcmalloc (sizeof (combinator_ctx_t)); hashcat_ctx->cpt_ctx = (cpt_ctx_t *) hcmalloc (sizeof (cpt_ctx_t)); hashcat_ctx->debugfile_ctx = (debugfile_ctx_t *) hcmalloc (sizeof (debugfile_ctx_t)); hashcat_ctx->dictstat_ctx = (dictstat_ctx_t *) hcmalloc (sizeof (dictstat_ctx_t)); hashcat_ctx->event_ctx = (event_ctx_t *) hcmalloc (sizeof (event_ctx_t)); hashcat_ctx->folder_config = (folder_config_t *) hcmalloc (sizeof (folder_config_t)); hashcat_ctx->hashcat_user = (hashcat_user_t *) hcmalloc (sizeof (hashcat_user_t)); hashcat_ctx->hashconfig = (hashconfig_t *) hcmalloc (sizeof (hashconfig_t)); hashcat_ctx->hashes = (hashes_t *) hcmalloc (sizeof (hashes_t)); hashcat_ctx->hwmon_ctx = (hwmon_ctx_t *) hcmalloc (sizeof (hwmon_ctx_t)); hashcat_ctx->induct_ctx = (induct_ctx_t *) hcmalloc (sizeof (induct_ctx_t)); hashcat_ctx->logfile_ctx = (logfile_ctx_t *) hcmalloc (sizeof (logfile_ctx_t)); hashcat_ctx->loopback_ctx = (loopback_ctx_t *) hcmalloc (sizeof (loopback_ctx_t)); hashcat_ctx->mask_ctx = (mask_ctx_t *) hcmalloc (sizeof (mask_ctx_t)); hashcat_ctx->module_ctx = (module_ctx_t *) hcmalloc (sizeof (module_ctx_t)); hashcat_ctx->backend_ctx = (backend_ctx_t *) hcmalloc (sizeof (backend_ctx_t)); hashcat_ctx->outcheck_ctx = (outcheck_ctx_t *) hcmalloc (sizeof (outcheck_ctx_t)); hashcat_ctx->outfile_ctx = (outfile_ctx_t *) hcmalloc (sizeof (outfile_ctx_t)); hashcat_ctx->pidfile_ctx = (pidfile_ctx_t *) hcmalloc (sizeof (pidfile_ctx_t)); hashcat_ctx->potfile_ctx = (potfile_ctx_t *) hcmalloc (sizeof (potfile_ctx_t)); hashcat_ctx->restore_ctx = (restore_ctx_t *) hcmalloc (sizeof (restore_ctx_t)); hashcat_ctx->status_ctx = (status_ctx_t *) hcmalloc (sizeof (status_ctx_t)); hashcat_ctx->straight_ctx = (straight_ctx_t *) hcmalloc (sizeof (straight_ctx_t)); hashcat_ctx->tuning_db = (tuning_db_t *) hcmalloc (sizeof (tuning_db_t)); hashcat_ctx->user_options_extra = (user_options_extra_t *) hcmalloc (sizeof (user_options_extra_t)); hashcat_ctx->user_options = (user_options_t *) hcmalloc (sizeof (user_options_t)); hashcat_ctx->wl_data = (wl_data_t *) hcmalloc (sizeof (wl_data_t)); return 0; } void hashcat_destroy (hashcat_ctx_t *hashcat_ctx) { hcfree (hashcat_ctx->brain_ctx); hcfree (hashcat_ctx->bitmap_ctx); hcfree (hashcat_ctx->combinator_ctx); hcfree (hashcat_ctx->cpt_ctx); hcfree (hashcat_ctx->debugfile_ctx); hcfree (hashcat_ctx->dictstat_ctx); hcfree (hashcat_ctx->event_ctx); hcfree (hashcat_ctx->folder_config); hcfree (hashcat_ctx->hashcat_user); hcfree (hashcat_ctx->hashconfig); hcfree (hashcat_ctx->hashes); hcfree (hashcat_ctx->hwmon_ctx); hcfree (hashcat_ctx->induct_ctx); hcfree (hashcat_ctx->logfile_ctx); hcfree (hashcat_ctx->loopback_ctx); hcfree (hashcat_ctx->mask_ctx); hcfree (hashcat_ctx->module_ctx); hcfree (hashcat_ctx->backend_ctx); hcfree (hashcat_ctx->outcheck_ctx); hcfree (hashcat_ctx->outfile_ctx); hcfree (hashcat_ctx->pidfile_ctx); hcfree (hashcat_ctx->potfile_ctx); hcfree (hashcat_ctx->restore_ctx); hcfree (hashcat_ctx->status_ctx); hcfree (hashcat_ctx->straight_ctx); hcfree (hashcat_ctx->tuning_db); hcfree (hashcat_ctx->user_options_extra); hcfree (hashcat_ctx->user_options); hcfree (hashcat_ctx->wl_data); memset (hashcat_ctx, 0, sizeof (hashcat_ctx_t)); } int hashcat_session_init (hashcat_ctx_t *hashcat_ctx, const char *install_folder, const char *shared_folder, int argc, char **argv, const int comptime) { user_options_t *user_options = hashcat_ctx->user_options; /** * make it a bit more comfortable to use some of the special modes in hashcat */ user_options_session_auto (hashcat_ctx); /** * event init (needed for logging so should be first) */ if (event_ctx_init (hashcat_ctx) == -1) return -1; /** * status init */ if (status_ctx_init (hashcat_ctx) == -1) return -1; /** * folder */ if (folder_config_init (hashcat_ctx, install_folder, shared_folder) == -1) return -1; /** * pidfile */ if (pidfile_ctx_init (hashcat_ctx) == -1) return -1; /** * restore */ if (restore_ctx_init (hashcat_ctx, argc, argv) == -1) return -1; /** * process user input */ user_options_preprocess (hashcat_ctx); user_options_extra_init (hashcat_ctx); user_options_postprocess (hashcat_ctx); /** * windows and sockets... */ #ifdef WITH_BRAIN #if defined (_WIN) if (user_options->brain_client == true) { WSADATA wsaData; WORD wVersionRequested = MAKEWORD (2,2); if (WSAStartup (wVersionRequested, &wsaData) != NO_ERROR) { fprintf (stderr, "WSAStartup: %s\n", strerror (errno)); return -1; } } #endif /** * brain */ if (brain_ctx_init (hashcat_ctx) == -1) return -1; #endif /** * logfile */ if (logfile_init (hashcat_ctx) == -1) return -1; /** * cpu affinity */ if (set_cpu_affinity (hashcat_ctx) == -1) return -1; /** * prepare seeding for random number generator, required by logfile and rules generator */ setup_seeding (user_options->rp_gen_seed_chgd, user_options->rp_gen_seed); /** * To help users a bit */ setup_environment_variables (hashcat_ctx->folder_config); setup_umask (); /** * tuning db */ if (tuning_db_init (hashcat_ctx) == -1) return -1; /** * induction directory */ if (induct_ctx_init (hashcat_ctx) == -1) return -1; /** * outfile-check directory */ if (outcheck_ctx_init (hashcat_ctx) == -1) return -1; /** * outfile itself */ if (outfile_init (hashcat_ctx) == -1) return -1; /** * potfile init * this is only setting path because potfile can be used in read and write mode depending on user options * plus it depends on hash_mode, so we continue using it in outer_loop */ if (potfile_init (hashcat_ctx) == -1) return -1; /** * dictstat init */ if (dictstat_init (hashcat_ctx) == -1) return -1; /** * loopback init */ if (loopback_init (hashcat_ctx) == -1) return -1; /** * debugfile init */ if (debugfile_init (hashcat_ctx) == -1) return -1; /** * Try to detect if all the files we're going to use are accessible in the mode we want them */ if (user_options_check_files (hashcat_ctx) == -1) return -1; /** * Init backend library loader */ if (backend_ctx_init (hashcat_ctx) == -1) return -1; /** * Init backend devices */ if (backend_ctx_devices_init (hashcat_ctx, comptime) == -1) return -1; /** * HM devices: init */ if (hwmon_ctx_init (hashcat_ctx) == -1) return -1; // done return 0; } bool autodetect_hashmode_test (hashcat_ctx_t *hashcat_ctx) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashes_t *hashes = hashcat_ctx->hashes; module_ctx_t *module_ctx = hashcat_ctx->module_ctx; user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; // check for file or hash on command line // if file, find out if binary file if (hashconfig->opts_type & OPTS_TYPE_AUTODETECT_DISABLE) return false; if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE) { if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE_OPTIONAL) { hashes->hashlist_mode = (hc_path_exist (user_options_extra->hc_hash) == true) ? HL_MODE_FILE_PLAIN : HL_MODE_ARG; if (hashes->hashlist_mode == HL_MODE_FILE_PLAIN) { hashes->hashfile = user_options_extra->hc_hash; } } else { hashes->hashlist_mode = HL_MODE_FILE_BINARY; if (hc_path_read (user_options_extra->hc_hash) == false) return false; hashes->hashfile = user_options_extra->hc_hash; } } else { hashes->hashlist_mode = (hc_path_exist (user_options_extra->hc_hash) == true) ? HL_MODE_FILE_PLAIN : HL_MODE_ARG; if (hashes->hashlist_mode == HL_MODE_FILE_PLAIN) { hashes->hashfile = user_options_extra->hc_hash; } } /** * load hashes, part I: find input mode */ const char *hashfile = hashes->hashfile; const u32 hashlist_mode = hashes->hashlist_mode; u32 hashlist_format = HLFMT_HASHCAT; if (hashlist_mode == HL_MODE_FILE_PLAIN) { HCFILE fp; if (hc_fopen (&fp, hashfile, "rb") == false) return false; hashlist_format = hlfmt_detect (hashcat_ctx, &fp, 100); hc_fclose (&fp); } hashes->hashlist_format = hashlist_format; /** * load hashes, part II: allocate required memory, set pointers */ void *digest = hccalloc (1, hashconfig->dgst_size); salt_t *salt = (salt_t *) hccalloc (1, sizeof (salt_t)); void *esalt = NULL; void *hook_salt = NULL; if (hashconfig->esalt_size > 0) { esalt = hccalloc (1, hashconfig->esalt_size); } if (hashconfig->hook_salt_size > 0) { hook_salt = hccalloc (1, hashconfig->hook_salt_size); } hashinfo_t *hash_info = (hashinfo_t *) hcmalloc (sizeof (hashinfo_t)); hash_info->user = (user_t *) hcmalloc (sizeof (user_t)); hash_info->orighash = (char *) hcmalloc (256); hash_info->split = (split_t *) hcmalloc (sizeof (split_t)); hash_t *hashes_buf = (hash_t *) hcmalloc (sizeof (hash_t)); hashes_buf->digest = digest; hashes_buf->salt = salt; hashes_buf->esalt = esalt; hashes_buf->hook_salt = hook_salt; hashes->hashes_buf = hashes_buf; hashes->digests_buf = digest; hashes->salts_buf = salt; hashes->esalts_buf = esalt; hashes->hook_salts_buf = hook_salt; bool success = false; 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; int hash_len = 0; hlfmt_hash (hashcat_ctx, hashlist_format, input_buf, input_len, &hash_buf, &hash_len); bool hash_fmt_error = false; if (hash_len < 1) hash_fmt_error = true; if (hash_buf == NULL) hash_fmt_error = true; if (hash_fmt_error) return false; const int parser_status = module_ctx->module_hash_decode (hashconfig, digest, salt, esalt, hook_salt, hash_info, hash_buf, hash_len); if (parser_status == PARSER_OK) success = true; } else if (hashlist_mode == HL_MODE_FILE_PLAIN) { HCFILE fp; int error_count = 0; if (hc_fopen (&fp, hashfile, "rb") == false) return false; char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!hc_feof (&fp)) { const size_t line_len = fgetl (&fp, line_buf, HCBUFSIZ_LARGE); if (line_len == 0) continue; 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 = false; if (hash_len < 1) hash_fmt_error = true; if (hash_buf == NULL) hash_fmt_error = true; if (hash_fmt_error) continue; int parser_status = module_ctx->module_hash_decode (hashconfig, digest, salt, esalt, hook_salt, hash_info, hash_buf, hash_len); if (parser_status == PARSER_OK) { success = true; break; } // abort this list after 100 errors if (error_count == 100) { break; } else { error_count++; } } hcfree (line_buf); hc_fclose (&fp); } else if (hashlist_mode == HL_MODE_FILE_BINARY) { char *input_buf = user_options_extra->hc_hash; size_t input_len = strlen (input_buf); if (module_ctx->module_hash_binary_parse != MODULE_DEFAULT) { const int hashes_parsed = module_ctx->module_hash_binary_parse (hashconfig, user_options, user_options_extra, hashes); if (hashes_parsed > 0) success = true; } else { const int parser_status = module_ctx->module_hash_decode (hashconfig, digest, salt, esalt, hook_salt, hash_info, input_buf, input_len); if (parser_status == PARSER_OK) success = true; } } hcfree (digest); hcfree (salt); hcfree (hash_info); hcfree (hashes_buf); if (hashconfig->esalt_size > 0) { hcfree (esalt); } if (hashconfig->hook_salt_size > 0) { hcfree (hook_salt); } hashes->digests_buf = NULL; hashes->salts_buf = NULL; hashes->esalts_buf = NULL; hashes->hook_salts_buf = NULL; return success; } int autodetect_hashmodes (hashcat_ctx_t *hashcat_ctx, usage_sort_t *usage_sort_buf) { folder_config_t *folder_config = hashcat_ctx->folder_config; user_options_t *user_options = hashcat_ctx->user_options; int usage_sort_cnt = 0; // save quiet state so we can restore later EVENT (EVENT_AUTODETECT_STARTING); const bool quiet_sav = user_options->quiet; user_options->quiet = true; char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY); if (modulefile == NULL) return -1; // brute force all the modes for (int i = 0; i < MODULE_HASH_MODES_MAXIMUM; i++) { user_options->hash_mode = i; // this is just to find out of that hash-mode exists or not module_filename (folder_config, i, modulefile, HCBUFSIZ_TINY); if (hc_path_exist (modulefile) == false) continue; // we know it exists, so load the plugin const int hashconfig_init_rc = hashconfig_init (hashcat_ctx); if (hashconfig_init_rc == 0) { const bool test_rc = autodetect_hashmode_test (hashcat_ctx); if (test_rc == true) { usage_sort_buf[usage_sort_cnt].hash_mode = hashcat_ctx->hashconfig->hash_mode; usage_sort_buf[usage_sort_cnt].hash_name = hcstrdup (hashcat_ctx->hashconfig->hash_name); usage_sort_buf[usage_sort_cnt].hash_category = hashcat_ctx->hashconfig->hash_category; usage_sort_cnt++; } } // clean up hashconfig_destroy (hashcat_ctx); } hcfree (modulefile); qsort (usage_sort_buf, usage_sort_cnt, sizeof (usage_sort_t), sort_by_usage); user_options->quiet = quiet_sav; EVENT (EVENT_AUTODETECT_FINISHED); return usage_sort_cnt; } int hashcat_session_execute (hashcat_ctx_t *hashcat_ctx) { folder_config_t *folder_config = hashcat_ctx->folder_config; logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_ctx; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; user_options_t *user_options = hashcat_ctx->user_options; backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx; // start logfile entry const time_t proc_start = time (NULL); logfile_generate_topid (hashcat_ctx); logfile_top_msg ("START"); // capture current working directory in session log // https://github.com/hashcat/hashcat/issues/2453 logfile_top_string (folder_config->cwd); logfile_top_string (folder_config->install_dir); logfile_top_string (folder_config->profile_dir); logfile_top_string (folder_config->session_dir); logfile_top_string (folder_config->shared_dir); // add all user options to logfile in case we want to debug some user session user_options_logger (hashcat_ctx); // read dictionary cache dictstat_read (hashcat_ctx); // autodetect if (user_options->autodetect == true) { status_ctx->devices_status = STATUS_AUTODETECT; usage_sort_t *usage_sort_buf = (usage_sort_t *) hccalloc (MODULE_HASH_MODES_MAXIMUM, sizeof (usage_sort_t)); if (usage_sort_buf == NULL) return -1; const int modes_cnt = autodetect_hashmodes (hashcat_ctx, usage_sort_buf); if (modes_cnt <= 0) { if (user_options->show == false) event_log_error (hashcat_ctx, "No hash-mode matches the structure of the input hash."); return -1; } if (modes_cnt > 1) { if (user_options->machine_readable == false) { event_log_info (hashcat_ctx, "The following %d hash-modes match the structure of your input hash:", modes_cnt); event_log_info (hashcat_ctx, NULL); event_log_info (hashcat_ctx, " # | Name | Category"); event_log_info (hashcat_ctx, " ======+============================================================+======================================"); } for (int i = 0; i < modes_cnt; i++) { if (user_options->machine_readable == false) { event_log_info (hashcat_ctx, "%7u | %-58s | %s", usage_sort_buf[i].hash_mode, usage_sort_buf[i].hash_name, strhashcategory (usage_sort_buf[i].hash_category)); } else { event_log_info (hashcat_ctx, "%u", usage_sort_buf[i].hash_mode); } hcfree (usage_sort_buf[i].hash_name); } hcfree (usage_sort_buf); if (user_options->machine_readable == false) event_log_info (hashcat_ctx, NULL); if (user_options->identify == false) { event_log_error (hashcat_ctx, "Please specify the hash-mode with -m [hash-mode]."); return -1; } return 0; } // modes_cnt == 1 if (user_options->identify == false) { event_log_warning (hashcat_ctx, "Hash-mode was not specified with -m. Attempting to auto-detect hash mode."); event_log_warning (hashcat_ctx, "The following mode was auto-detected as the only one matching your input hash:"); } if (user_options->identify == true) { if (user_options->machine_readable == true) { event_log_info (hashcat_ctx, "%u", usage_sort_buf[0].hash_mode); } else { event_log_info (hashcat_ctx, "The following hash-mode match the structure of your input hash:"); event_log_info (hashcat_ctx, NULL); event_log_info (hashcat_ctx, " # | Name | Category"); event_log_info (hashcat_ctx, " ======+============================================================+======================================"); event_log_info (hashcat_ctx, "%7u | %-58s | %s", usage_sort_buf[0].hash_mode, usage_sort_buf[0].hash_name, strhashcategory (usage_sort_buf[0].hash_category)); event_log_info (hashcat_ctx, NULL); } } else { event_log_info (hashcat_ctx, "\n%u | %s | %s\n", usage_sort_buf[0].hash_mode, usage_sort_buf[0].hash_name, strhashcategory (usage_sort_buf[0].hash_category)); } if (user_options->identify == false) { event_log_warning (hashcat_ctx, "NOTE: Auto-detect is best effort. The correct hash-mode is NOT guaranteed!"); event_log_warning (hashcat_ctx, "Do NOT report auto-detect issues unless you are certain of the hash type."); event_log_warning (hashcat_ctx, NULL); } user_options->hash_mode = usage_sort_buf[0].hash_mode; hcfree (usage_sort_buf[0].hash_name); hcfree (usage_sort_buf); if (user_options->identify == true) return 0; user_options->autodetect = false; } /** * outer loop */ EVENT (EVENT_OUTERLOOP_STARTING); int rc_final = -1; if (user_options->benchmark == true) { const bool quiet_sav = user_options->quiet; user_options->quiet = true; if (user_options->hash_mode_chgd == true) { rc_final = outer_loop (hashcat_ctx); if (rc_final == -1) myabort (hashcat_ctx); } else { int hash_mode = 0; while ((hash_mode = benchmark_next (hashcat_ctx)) != -1) { user_options->hash_mode = hash_mode; rc_final = outer_loop (hashcat_ctx); if (rc_final == -1) myabort (hashcat_ctx); if (status_ctx->run_main_level1 == false) break; } } user_options->quiet = quiet_sav; } else { const bool quiet_sav = user_options->quiet; if (user_options->speed_only == true) user_options->quiet = true; rc_final = outer_loop (hashcat_ctx); if (rc_final == -1) myabort (hashcat_ctx); if (user_options->speed_only == true) user_options->quiet = quiet_sav; } EVENT (EVENT_OUTERLOOP_FINISHED); // if exhausted or cracked, unlink the restore file unlink_restore (hashcat_ctx); // final update dictionary cache dictstat_write (hashcat_ctx); // final logfile entry const time_t proc_stop = time (NULL); logfile_top_uint (proc_start); logfile_top_uint (proc_stop); logfile_top_msg ("STOP"); // set final status code if (rc_final == 0) { if (status_ctx->devices_status == STATUS_ABORTED_FINISH) rc_final = 5; if (status_ctx->devices_status == STATUS_ABORTED_RUNTIME) rc_final = 4; if (status_ctx->devices_status == STATUS_ABORTED_CHECKPOINT) rc_final = 3; if (status_ctx->devices_status == STATUS_ABORTED) rc_final = 2; if (status_ctx->devices_status == STATUS_QUIT) rc_final = 2; if (status_ctx->devices_status == STATUS_EXHAUSTED) rc_final = 1; if (status_ctx->devices_status == STATUS_CRACKED) rc_final = 0; if (status_ctx->devices_status == STATUS_ERROR) rc_final = -1; } else if (rc_final == -1) { // setup the new negative status code, usefull in test.sh // -2 is marked as used in status_codes.txt if (backend_ctx->runtime_skip_warning == true) rc_final = -3; if (backend_ctx->memory_hit_warning == true) rc_final = -4; if (backend_ctx->kernel_build_warning == true) rc_final = -5; if (backend_ctx->kernel_create_warning == true) rc_final = -6; if (backend_ctx->kernel_accel_warnings == true) rc_final = -7; if (backend_ctx->extra_size_warning == true) rc_final = -8; if (backend_ctx->mixed_warnings == true) rc_final = -9; } // special case for --stdout if (user_options->stdout_flag == true) { if (status_ctx->devices_status == STATUS_EXHAUSTED) { rc_final = 0; } } // done return rc_final; } int hashcat_session_pause (hashcat_ctx_t *hashcat_ctx) { return SuspendThreads (hashcat_ctx); } int hashcat_session_resume (hashcat_ctx_t *hashcat_ctx) { return ResumeThreads (hashcat_ctx); } int hashcat_session_bypass (hashcat_ctx_t *hashcat_ctx) { return bypass (hashcat_ctx); } int hashcat_session_checkpoint (hashcat_ctx_t *hashcat_ctx) { return stop_at_checkpoint (hashcat_ctx); } int hashcat_session_finish (hashcat_ctx_t *hashcat_ctx) { return finish_after_attack (hashcat_ctx); } int hashcat_session_quit (hashcat_ctx_t *hashcat_ctx) { return myabort (hashcat_ctx); } int hashcat_session_destroy (hashcat_ctx_t *hashcat_ctx) { #ifdef WITH_BRAIN #if defined (_WIN) user_options_t *user_options = hashcat_ctx->user_options; if (user_options->brain_client == true) { WSACleanup (); } #endif #endif debugfile_destroy (hashcat_ctx); dictstat_destroy (hashcat_ctx); folder_config_destroy (hashcat_ctx); hwmon_ctx_destroy (hashcat_ctx); induct_ctx_destroy (hashcat_ctx); logfile_destroy (hashcat_ctx); loopback_destroy (hashcat_ctx); backend_ctx_devices_destroy (hashcat_ctx); backend_ctx_destroy (hashcat_ctx); outcheck_ctx_destroy (hashcat_ctx); outfile_destroy (hashcat_ctx); pidfile_ctx_destroy (hashcat_ctx); potfile_destroy (hashcat_ctx); restore_ctx_destroy (hashcat_ctx); tuning_db_destroy (hashcat_ctx); user_options_destroy (hashcat_ctx); user_options_extra_destroy (hashcat_ctx); status_ctx_destroy (hashcat_ctx); event_ctx_destroy (hashcat_ctx); return 0; } char *hashcat_get_log (hashcat_ctx_t *hashcat_ctx) { event_ctx_t *event_ctx = hashcat_ctx->event_ctx; return event_ctx->msg_buf; } int hashcat_get_status (hashcat_ctx_t *hashcat_ctx, hashcat_status_t *hashcat_status) { const status_ctx_t *status_ctx = hashcat_ctx->status_ctx; memset (hashcat_status, 0, sizeof (hashcat_status_t)); if (status_ctx == NULL) return -1; // way too early if (status_ctx->accessible == false) { if (status_ctx->hashcat_status_final->msec_running > 0) { memcpy (hashcat_status, status_ctx->hashcat_status_final, sizeof (hashcat_status_t)); return 0; } return -1; // still too early } hashcat_status->digests_cnt = status_get_digests_cnt (hashcat_ctx); hashcat_status->digests_done = status_get_digests_done (hashcat_ctx); hashcat_status->digests_done_new = status_get_digests_done_new (hashcat_ctx); hashcat_status->digests_done_pot = status_get_digests_done_pot (hashcat_ctx); hashcat_status->digests_percent = status_get_digests_percent (hashcat_ctx); hashcat_status->hash_target = status_get_hash_target (hashcat_ctx); hashcat_status->hash_name = status_get_hash_name (hashcat_ctx); hashcat_status->guess_base = status_get_guess_base (hashcat_ctx); hashcat_status->guess_base_offset = status_get_guess_base_offset (hashcat_ctx); hashcat_status->guess_base_count = status_get_guess_base_count (hashcat_ctx); hashcat_status->guess_base_percent = status_get_guess_base_percent (hashcat_ctx); hashcat_status->guess_mod = status_get_guess_mod (hashcat_ctx); hashcat_status->guess_mod_offset = status_get_guess_mod_offset (hashcat_ctx); hashcat_status->guess_mod_count = status_get_guess_mod_count (hashcat_ctx); hashcat_status->guess_mod_percent = status_get_guess_mod_percent (hashcat_ctx); hashcat_status->guess_charset = status_get_guess_charset (hashcat_ctx); hashcat_status->guess_mask_length = status_get_guess_mask_length (hashcat_ctx); hashcat_status->guess_mode = status_get_guess_mode (hashcat_ctx); hashcat_status->msec_paused = status_get_msec_paused (hashcat_ctx); hashcat_status->msec_running = status_get_msec_running (hashcat_ctx); hashcat_status->msec_real = status_get_msec_real (hashcat_ctx); hashcat_status->progress_mode = status_get_progress_mode (hashcat_ctx); hashcat_status->progress_finished_percent = status_get_progress_finished_percent (hashcat_ctx); hashcat_status->progress_cur_relative_skip = status_get_progress_cur_relative_skip (hashcat_ctx); hashcat_status->progress_cur = status_get_progress_cur (hashcat_ctx); hashcat_status->progress_done = status_get_progress_done (hashcat_ctx); hashcat_status->progress_end_relative_skip = status_get_progress_end_relative_skip (hashcat_ctx); hashcat_status->progress_end = status_get_progress_end (hashcat_ctx); hashcat_status->progress_ignore = status_get_progress_ignore (hashcat_ctx); hashcat_status->progress_rejected = status_get_progress_rejected (hashcat_ctx); hashcat_status->progress_rejected_percent = status_get_progress_rejected_percent (hashcat_ctx); hashcat_status->progress_restored = status_get_progress_restored (hashcat_ctx); hashcat_status->progress_skip = status_get_progress_skip (hashcat_ctx); hashcat_status->restore_point = status_get_restore_point (hashcat_ctx); hashcat_status->restore_total = status_get_restore_total (hashcat_ctx); hashcat_status->restore_percent = status_get_restore_percent (hashcat_ctx); hashcat_status->salts_cnt = status_get_salts_cnt (hashcat_ctx); hashcat_status->salts_done = status_get_salts_done (hashcat_ctx); hashcat_status->salts_percent = status_get_salts_percent (hashcat_ctx); hashcat_status->session = status_get_session (hashcat_ctx); #ifdef WITH_BRAIN hashcat_status->brain_session = status_get_brain_session (hashcat_ctx); hashcat_status->brain_attack = status_get_brain_attack (hashcat_ctx); hashcat_status->brain_rx_all = status_get_brain_rx_all (hashcat_ctx); hashcat_status->brain_tx_all = status_get_brain_tx_all (hashcat_ctx); #endif hashcat_status->status_string = status_get_status_string (hashcat_ctx); hashcat_status->status_number = status_get_status_number (hashcat_ctx); hashcat_status->time_estimated_absolute = status_get_time_estimated_absolute (hashcat_ctx); hashcat_status->time_estimated_relative = status_get_time_estimated_relative (hashcat_ctx); hashcat_status->time_started_absolute = status_get_time_started_absolute (hashcat_ctx); hashcat_status->time_started_relative = status_get_time_started_relative (hashcat_ctx); hashcat_status->cpt_cur_min = status_get_cpt_cur_min (hashcat_ctx); hashcat_status->cpt_cur_hour = status_get_cpt_cur_hour (hashcat_ctx); hashcat_status->cpt_cur_day = status_get_cpt_cur_day (hashcat_ctx); hashcat_status->cpt_avg_min = status_get_cpt_avg_min (hashcat_ctx); hashcat_status->cpt_avg_hour = status_get_cpt_avg_hour (hashcat_ctx); hashcat_status->cpt_avg_day = status_get_cpt_avg_day (hashcat_ctx); hashcat_status->cpt = status_get_cpt (hashcat_ctx); // multiple devices hashcat_status->device_info_cnt = status_get_device_info_cnt (hashcat_ctx); hashcat_status->device_info_active = status_get_device_info_active (hashcat_ctx); for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { device_info_t *device_info = hashcat_status->device_info_buf + device_id; device_info->skipped_dev = status_get_skipped_dev (hashcat_ctx, device_id); device_info->skipped_warning_dev = status_get_skipped_warning_dev (hashcat_ctx, device_id); device_info->hashes_msec_dev = status_get_hashes_msec_dev (hashcat_ctx, device_id); device_info->hashes_msec_dev_benchmark = status_get_hashes_msec_dev_benchmark (hashcat_ctx, device_id); device_info->exec_msec_dev = status_get_exec_msec_dev (hashcat_ctx, device_id); device_info->speed_sec_dev = status_get_speed_sec_dev (hashcat_ctx, device_id); device_info->guess_candidates_dev = status_get_guess_candidates_dev (hashcat_ctx, device_id); #if defined(__APPLE__) device_info->hwmon_fan_dev = status_get_hwmon_fan_dev (hashcat_ctx); #endif device_info->hwmon_dev = status_get_hwmon_dev (hashcat_ctx, device_id); device_info->corespeed_dev = status_get_corespeed_dev (hashcat_ctx, device_id); device_info->memoryspeed_dev = status_get_memoryspeed_dev (hashcat_ctx, device_id); device_info->progress_dev = status_get_progress_dev (hashcat_ctx, device_id); device_info->runtime_msec_dev = status_get_runtime_msec_dev (hashcat_ctx, device_id); device_info->kernel_accel_dev = status_get_kernel_accel_dev (hashcat_ctx, device_id); device_info->kernel_loops_dev = status_get_kernel_loops_dev (hashcat_ctx, device_id); device_info->kernel_threads_dev = status_get_kernel_threads_dev (hashcat_ctx, device_id); device_info->vector_width_dev = status_get_vector_width_dev (hashcat_ctx, device_id); device_info->salt_pos_dev = status_get_salt_pos_dev (hashcat_ctx, device_id); device_info->innerloop_pos_dev = status_get_innerloop_pos_dev (hashcat_ctx, device_id); device_info->innerloop_left_dev = status_get_innerloop_left_dev (hashcat_ctx, device_id); device_info->iteration_pos_dev = status_get_iteration_pos_dev (hashcat_ctx, device_id); device_info->iteration_left_dev = status_get_iteration_left_dev (hashcat_ctx, device_id); device_info->device_name = status_get_device_name (hashcat_ctx, device_id); device_info->device_type = status_get_device_type (hashcat_ctx, device_id); #ifdef WITH_BRAIN device_info->brain_link_client_id_dev = status_get_brain_link_client_id_dev (hashcat_ctx, device_id); device_info->brain_link_status_dev = status_get_brain_link_status_dev (hashcat_ctx, device_id); device_info->brain_link_recv_bytes_dev = status_get_brain_link_recv_bytes_dev (hashcat_ctx, device_id); device_info->brain_link_send_bytes_dev = status_get_brain_link_send_bytes_dev (hashcat_ctx, device_id); device_info->brain_link_recv_bytes_sec_dev = status_get_brain_link_recv_bytes_sec_dev (hashcat_ctx, device_id); device_info->brain_link_send_bytes_sec_dev = status_get_brain_link_send_bytes_sec_dev (hashcat_ctx, device_id); #endif } hashcat_status->hashes_msec_all = status_get_hashes_msec_all (hashcat_ctx); hashcat_status->exec_msec_all = status_get_exec_msec_all (hashcat_ctx); hashcat_status->speed_sec_all = status_get_speed_sec_all (hashcat_ctx); return 0; }