/** * Author......: See docs/credits.txt * License.....: MIT */ #include "common.h" #include "types.h" #include "memory.h" #include "event.h" #include "logfile.h" #include "interface.h" #include "shared.h" #include "usage.h" #include "backend.h" #include "user_options.h" #include "outfile.h" #ifdef WITH_BRAIN #include "brain.h" #endif #ifdef WITH_BRAIN static const char *short_options = "hVvm:a:r:j:k:g:o:t:d:D:n:u:T:c:p:s:l:1:2:3:4:iIbw:OSz"; #else static const char *short_options = "hVvm:a:r:j:k:g:o:t:d:D:n:u:T:c:p:s:l:1:2:3:4:iIbw:OS"; #endif static const struct option long_options[] = { {"advice-disable", no_argument, NULL, IDX_ADVICE_DISABLE}, {"attack-mode", required_argument, NULL, IDX_ATTACK_MODE}, {"backend-devices", required_argument, NULL, IDX_BACKEND_DEVICES}, {"backend-ignore-cuda", no_argument, NULL, IDX_BACKEND_IGNORE_CUDA}, {"backend-ignore-opencl", no_argument, NULL, IDX_BACKEND_IGNORE_OPENCL}, {"backend-info", no_argument, NULL, IDX_BACKEND_INFO}, {"backend-vector-width", required_argument, NULL, IDX_BACKEND_VECTOR_WIDTH}, {"benchmark-all", no_argument, NULL, IDX_BENCHMARK_ALL}, {"benchmark", no_argument, NULL, IDX_BENCHMARK}, {"bitmap-max", required_argument, NULL, IDX_BITMAP_MAX}, {"bitmap-min", required_argument, NULL, IDX_BITMAP_MIN}, {"cpu-affinity", required_argument, NULL, IDX_CPU_AFFINITY}, {"custom-charset1", required_argument, NULL, IDX_CUSTOM_CHARSET_1}, {"custom-charset2", required_argument, NULL, IDX_CUSTOM_CHARSET_2}, {"custom-charset3", required_argument, NULL, IDX_CUSTOM_CHARSET_3}, {"custom-charset4", required_argument, NULL, IDX_CUSTOM_CHARSET_4}, {"debug-file", required_argument, NULL, IDX_DEBUG_FILE}, {"debug-mode", required_argument, NULL, IDX_DEBUG_MODE}, {"encoding-from", required_argument, NULL, IDX_ENCODING_FROM}, {"encoding-to", required_argument, NULL, IDX_ENCODING_TO}, {"example-hashes", no_argument, NULL, IDX_HASH_INFO}, // alias of hash-info {"force", no_argument, NULL, IDX_FORCE}, {"generate-rules-func-max", required_argument, NULL, IDX_RP_GEN_FUNC_MAX}, {"generate-rules-func-min", required_argument, NULL, IDX_RP_GEN_FUNC_MIN}, {"generate-rules", required_argument, NULL, IDX_RP_GEN}, {"generate-rules-seed", required_argument, NULL, IDX_RP_GEN_SEED}, {"hwmon-disable", no_argument, NULL, IDX_HWMON_DISABLE}, {"hwmon-temp-abort", required_argument, NULL, IDX_HWMON_TEMP_ABORT}, {"hash-info", no_argument, NULL, IDX_HASH_INFO}, {"hash-type", required_argument, NULL, IDX_HASH_MODE}, {"hccapx-message-pair", required_argument, NULL, IDX_HCCAPX_MESSAGE_PAIR}, {"help", no_argument, NULL, IDX_HELP}, {"hex-charset", no_argument, NULL, IDX_HEX_CHARSET}, {"hex-salt", no_argument, NULL, IDX_HEX_SALT}, {"hex-wordlist", no_argument, NULL, IDX_HEX_WORDLIST}, {"hook-threads", required_argument, NULL, IDX_HOOK_THREADS}, {"increment-max", required_argument, NULL, IDX_INCREMENT_MAX}, {"increment-min", required_argument, NULL, IDX_INCREMENT_MIN}, {"increment", no_argument, NULL, IDX_INCREMENT}, {"induction-dir", required_argument, NULL, IDX_INDUCTION_DIR}, {"keep-guessing", no_argument, NULL, IDX_KEEP_GUESSING}, {"kernel-accel", required_argument, NULL, IDX_KERNEL_ACCEL}, {"kernel-loops", required_argument, NULL, IDX_KERNEL_LOOPS}, {"kernel-threads", required_argument, NULL, IDX_KERNEL_THREADS}, {"keyboard-layout-mapping", required_argument, NULL, IDX_KEYBOARD_LAYOUT_MAPPING}, {"keyspace", no_argument, NULL, IDX_KEYSPACE}, {"left", no_argument, NULL, IDX_LEFT}, {"limit", required_argument, NULL, IDX_LIMIT}, {"logfile-disable", no_argument, NULL, IDX_LOGFILE_DISABLE}, {"loopback", no_argument, NULL, IDX_LOOPBACK}, {"machine-readable", no_argument, NULL, IDX_MACHINE_READABLE}, {"markov-classic", no_argument, NULL, IDX_MARKOV_CLASSIC}, {"markov-disable", no_argument, NULL, IDX_MARKOV_DISABLE}, {"markov-hcstat2", required_argument, NULL, IDX_MARKOV_HCSTAT2}, {"markov-threshold", required_argument, NULL, IDX_MARKOV_THRESHOLD}, {"nonce-error-corrections", required_argument, NULL, IDX_NONCE_ERROR_CORRECTIONS}, {"opencl-device-types", required_argument, NULL, IDX_OPENCL_DEVICE_TYPES}, {"optimized-kernel-enable", no_argument, NULL, IDX_OPTIMIZED_KERNEL_ENABLE}, {"outfile-autohex-disable", no_argument, NULL, IDX_OUTFILE_AUTOHEX_DISABLE}, {"outfile-check-dir", required_argument, NULL, IDX_OUTFILE_CHECK_DIR}, {"outfile-check-timer", required_argument, NULL, IDX_OUTFILE_CHECK_TIMER}, {"outfile-format", required_argument, NULL, IDX_OUTFILE_FORMAT}, {"outfile", required_argument, NULL, IDX_OUTFILE}, {"potfile-disable", no_argument, NULL, IDX_POTFILE_DISABLE}, {"potfile-path", required_argument, NULL, IDX_POTFILE_PATH}, {"progress-only", no_argument, NULL, IDX_PROGRESS_ONLY}, {"quiet", no_argument, NULL, IDX_QUIET}, {"remove", no_argument, NULL, IDX_REMOVE}, {"remove-timer", required_argument, NULL, IDX_REMOVE_TIMER}, {"restore-disable", no_argument, NULL, IDX_RESTORE_DISABLE}, {"restore-file-path", required_argument, NULL, IDX_RESTORE_FILE_PATH}, {"restore", no_argument, NULL, IDX_RESTORE}, {"rule-left", required_argument, NULL, IDX_RULE_BUF_L}, {"rule-right", required_argument, NULL, IDX_RULE_BUF_R}, {"rules-file", required_argument, NULL, IDX_RP_FILE}, {"runtime", required_argument, NULL, IDX_RUNTIME}, {"scrypt-tmto", required_argument, NULL, IDX_SCRYPT_TMTO}, {"segment-size", required_argument, NULL, IDX_SEGMENT_SIZE}, {"self-test-disable", no_argument, NULL, IDX_SELF_TEST_DISABLE}, {"separator", required_argument, NULL, IDX_SEPARATOR}, {"seperator", required_argument, NULL, IDX_SEPARATOR}, {"session", required_argument, NULL, IDX_SESSION}, {"show", no_argument, NULL, IDX_SHOW}, {"skip", required_argument, NULL, IDX_SKIP}, {"slow-candidates", no_argument, NULL, IDX_SLOW_CANDIDATES}, {"speed-only", no_argument, NULL, IDX_SPEED_ONLY}, {"spin-damp", required_argument, NULL, IDX_SPIN_DAMP}, {"status", no_argument, NULL, IDX_STATUS}, {"status-json", no_argument, NULL, IDX_STATUS_JSON}, {"status-timer", required_argument, NULL, IDX_STATUS_TIMER}, {"stdout", no_argument, NULL, IDX_STDOUT_FLAG}, {"stdin-timeout-abort", required_argument, NULL, IDX_STDIN_TIMEOUT_ABORT}, {"truecrypt-keyfiles", required_argument, NULL, IDX_TRUECRYPT_KEYFILES}, {"username", no_argument, NULL, IDX_USERNAME}, {"veracrypt-keyfiles", required_argument, NULL, IDX_VERACRYPT_KEYFILES}, {"veracrypt-pim-start", required_argument, NULL, IDX_VERACRYPT_PIM_START}, {"veracrypt-pim-stop", required_argument, NULL, IDX_VERACRYPT_PIM_STOP}, {"version", no_argument, NULL, IDX_VERSION}, {"wordlist-autohex-disable", no_argument, NULL, IDX_WORDLIST_AUTOHEX_DISABLE}, {"workload-profile", required_argument, NULL, IDX_WORKLOAD_PROFILE}, #ifdef WITH_BRAIN {"brain-client", no_argument, NULL, IDX_BRAIN_CLIENT}, {"brain-client-features", required_argument, NULL, IDX_BRAIN_CLIENT_FEATURES}, {"brain-server", no_argument, NULL, IDX_BRAIN_SERVER}, {"brain-server-timer", required_argument, NULL, IDX_BRAIN_SERVER_TIMER}, {"brain-host", required_argument, NULL, IDX_BRAIN_HOST}, {"brain-port", required_argument, NULL, IDX_BRAIN_PORT}, {"brain-password", required_argument, NULL, IDX_BRAIN_PASSWORD}, {"brain-session", required_argument, NULL, IDX_BRAIN_SESSION}, {"brain-session-whitelist", required_argument, NULL, IDX_BRAIN_SESSION_WHITELIST}, #endif {NULL, 0, NULL, 0 } }; static const char *ENCODING_FROM = "utf-8"; static const char *ENCODING_TO = "utf-8"; static const char *RULE_BUF_R = ":"; static const char *RULE_BUF_L = ":"; static const char *DEF_MASK_CS_1 = "?l?d?u"; static const char *DEF_MASK_CS_2 = "?l?d"; static const char *DEF_MASK_CS_3 = "?l?d*!$@_"; int user_options_init (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; user_options->advice_disable = ADVICE_DISABLE; user_options->attack_mode = ATTACK_MODE; user_options->autodetect = AUTODETECT; user_options->backend_devices = NULL; user_options->backend_ignore_cuda = BACKEND_IGNORE_CUDA; user_options->backend_ignore_opencl = BACKEND_IGNORE_OPENCL; user_options->backend_info = BACKEND_INFO; user_options->backend_vector_width = BACKEND_VECTOR_WIDTH; user_options->benchmark_all = BENCHMARK_ALL; user_options->benchmark = BENCHMARK; user_options->bitmap_max = BITMAP_MAX; user_options->bitmap_min = BITMAP_MIN; #ifdef WITH_BRAIN user_options->brain_client = BRAIN_CLIENT; user_options->brain_client_features = BRAIN_CLIENT_FEATURES; user_options->brain_host = NULL; user_options->brain_port = BRAIN_PORT; user_options->brain_server = BRAIN_SERVER; user_options->brain_server_timer = BRAIN_SERVER_TIMER; user_options->brain_session = BRAIN_SESSION; user_options->brain_session_whitelist = NULL; #endif user_options->cpu_affinity = NULL; user_options->custom_charset_1 = NULL; user_options->custom_charset_2 = NULL; user_options->custom_charset_3 = NULL; user_options->custom_charset_4 = NULL; user_options->debug_file = NULL; user_options->debug_mode = DEBUG_MODE; user_options->encoding_from = ENCODING_FROM; user_options->encoding_to = ENCODING_TO; user_options->force = FORCE; user_options->hwmon_disable = HWMON_DISABLE; user_options->hwmon_temp_abort = HWMON_TEMP_ABORT; user_options->hash_info = HASH_INFO; user_options->hash_mode = HASH_MODE; user_options->hccapx_message_pair = HCCAPX_MESSAGE_PAIR; user_options->hex_charset = HEX_CHARSET; user_options->hex_salt = HEX_SALT; user_options->hex_wordlist = HEX_WORDLIST; user_options->hook_threads = HOOK_THREADS; user_options->increment = INCREMENT; user_options->increment_max = INCREMENT_MAX; user_options->increment_min = INCREMENT_MIN; user_options->induction_dir = NULL; user_options->keep_guessing = KEEP_GUESSING; user_options->kernel_accel = KERNEL_ACCEL; user_options->kernel_loops = KERNEL_LOOPS; user_options->kernel_threads = KERNEL_THREADS; user_options->keyboard_layout_mapping = NULL; user_options->keyspace = KEYSPACE; user_options->left = LEFT; user_options->limit = LIMIT; user_options->logfile_disable = LOGFILE_DISABLE; user_options->loopback = LOOPBACK; user_options->machine_readable = MACHINE_READABLE; user_options->markov_classic = MARKOV_CLASSIC; user_options->markov_disable = MARKOV_DISABLE; user_options->markov_hcstat2 = NULL; user_options->markov_threshold = MARKOV_THRESHOLD; user_options->nonce_error_corrections = NONCE_ERROR_CORRECTIONS; user_options->opencl_device_types = NULL; user_options->optimized_kernel_enable = OPTIMIZED_KERNEL_ENABLE; user_options->outfile_autohex = OUTFILE_AUTOHEX; user_options->outfile_check_dir = NULL; user_options->outfile_check_timer = OUTFILE_CHECK_TIMER; user_options->outfile_format = OUTFILE_FORMAT; user_options->outfile = NULL; user_options->potfile_disable = POTFILE_DISABLE; user_options->potfile_path = NULL; user_options->progress_only = PROGRESS_ONLY; user_options->quiet = QUIET; user_options->remove = REMOVE; user_options->remove_timer = REMOVE_TIMER; user_options->restore_disable = RESTORE_DISABLE; user_options->restore_file_path = NULL; user_options->restore = RESTORE; user_options->restore_timer = RESTORE_TIMER; user_options->rp_gen_func_max = RP_GEN_FUNC_MAX; user_options->rp_gen_func_min = RP_GEN_FUNC_MIN; user_options->rp_gen = RP_GEN; user_options->rp_gen_seed = RP_GEN_SEED; user_options->rule_buf_l = RULE_BUF_L; user_options->rule_buf_r = RULE_BUF_R; user_options->runtime = RUNTIME; user_options->scrypt_tmto = SCRYPT_TMTO; user_options->segment_size = SEGMENT_SIZE; user_options->self_test_disable = SELF_TEST_DISABLE; user_options->separator = SEPARATOR; user_options->session = PROGNAME; user_options->show = SHOW; user_options->skip = SKIP; user_options->slow_candidates = SLOW_CANDIDATES; user_options->speed_only = SPEED_ONLY; user_options->spin_damp = SPIN_DAMP; user_options->status = STATUS; user_options->status_json = STATUS_JSON; user_options->status_timer = STATUS_TIMER; user_options->stdin_timeout_abort = STDIN_TIMEOUT_ABORT; user_options->stdout_flag = STDOUT_FLAG; user_options->truecrypt_keyfiles = NULL; user_options->usage = USAGE; user_options->username = USERNAME; user_options->veracrypt_keyfiles = NULL; user_options->veracrypt_pim_start = VERACRYPT_PIM_START; user_options->veracrypt_pim_stop = VERACRYPT_PIM_STOP; user_options->version = VERSION; user_options->wordlist_autohex_disable = WORDLIST_AUTOHEX_DISABLE; user_options->workload_profile = WORKLOAD_PROFILE; user_options->rp_files_cnt = 0; user_options->rp_files = (char **) hccalloc (256, sizeof (char *)); user_options->hc_bin = PROGNAME; user_options->hc_argc = 0; user_options->hc_argv = NULL; return 0; } void user_options_destroy (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; hcfree (user_options->rp_files); //do not reset this, it might be used from main.c //memset (user_options, 0, sizeof (user_options_t)); } int user_options_getopt (hashcat_ctx_t *hashcat_ctx, int argc, char **argv) { user_options_t *user_options = hashcat_ctx->user_options; int c = -1; int option_index; optind = 1; optopt = 0; option_index = 0; while ((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) { switch (c) { case IDX_REMOVE_TIMER: case IDX_DEBUG_MODE: case IDX_SKIP: case IDX_LIMIT: case IDX_STATUS_TIMER: case IDX_HASH_MODE: case IDX_RUNTIME: case IDX_ATTACK_MODE: case IDX_RP_GEN: case IDX_RP_GEN_FUNC_MIN: case IDX_RP_GEN_FUNC_MAX: case IDX_RP_GEN_SEED: case IDX_MARKOV_THRESHOLD: case IDX_OUTFILE_CHECK_TIMER: case IDX_BACKEND_VECTOR_WIDTH: case IDX_WORKLOAD_PROFILE: case IDX_KERNEL_ACCEL: case IDX_KERNEL_LOOPS: case IDX_KERNEL_THREADS: case IDX_SPIN_DAMP: case IDX_HWMON_TEMP_ABORT: case IDX_HCCAPX_MESSAGE_PAIR: case IDX_NONCE_ERROR_CORRECTIONS: case IDX_VERACRYPT_PIM_START: case IDX_VERACRYPT_PIM_STOP: case IDX_SEGMENT_SIZE: case IDX_SCRYPT_TMTO: case IDX_BITMAP_MIN: case IDX_BITMAP_MAX: case IDX_INCREMENT_MIN: case IDX_INCREMENT_MAX: case IDX_HOOK_THREADS: #ifdef WITH_BRAIN case IDX_BRAIN_PORT: #endif if (hc_string_is_digit (optarg) == false) { event_log_error (hashcat_ctx, "The specified parameter cannot use '%s' as a value - must be a number.", optarg); return -1; } break; case '?': { event_log_error (hashcat_ctx, "Invalid argument specified."); return -1; } } } optind = 1; optopt = 0; option_index = 0; while ((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) { switch (c) { case IDX_HELP: user_options->usage = true; break; case IDX_VERSION: user_options->version = true; break; case IDX_RESTORE: user_options->restore = true; break; case IDX_QUIET: user_options->quiet = true; break; case IDX_SHOW: user_options->show = true; break; case IDX_LEFT: user_options->left = true; break; case IDX_ADVICE_DISABLE: user_options->advice_disable = true; break; case IDX_USERNAME: user_options->username = true; break; case IDX_REMOVE: user_options->remove = true; break; case IDX_REMOVE_TIMER: user_options->remove_timer = hc_strtoul (optarg, NULL, 10); user_options->remove_timer_chgd = true; break; case IDX_POTFILE_DISABLE: user_options->potfile_disable = true; break; case IDX_POTFILE_PATH: user_options->potfile_path = optarg; break; case IDX_DEBUG_MODE: user_options->debug_mode = hc_strtoul (optarg, NULL, 10); break; case IDX_DEBUG_FILE: user_options->debug_file = optarg; break; case IDX_ENCODING_FROM: user_options->encoding_from = optarg; break; case IDX_ENCODING_TO: user_options->encoding_to = optarg; break; case IDX_INDUCTION_DIR: user_options->induction_dir = optarg; break; case IDX_OUTFILE_CHECK_DIR: user_options->outfile_check_dir = optarg; break; case IDX_HASH_INFO: user_options->hash_info = true; break; case IDX_FORCE: user_options->force = true; break; case IDX_SELF_TEST_DISABLE: user_options->self_test_disable = true; break; case IDX_SKIP: user_options->skip = hc_strtoull (optarg, NULL, 10); user_options->skip_chgd = true; break; case IDX_LIMIT: user_options->limit = hc_strtoull (optarg, NULL, 10); user_options->limit_chgd = true; break; case IDX_KEEP_GUESSING: user_options->keep_guessing = true; break; case IDX_KEYSPACE: user_options->keyspace = true; break; case IDX_BENCHMARK: user_options->benchmark = true; break; case IDX_BENCHMARK_ALL: user_options->benchmark_all = true; break; case IDX_STDOUT_FLAG: user_options->stdout_flag = true; break; case IDX_STDIN_TIMEOUT_ABORT: user_options->stdin_timeout_abort = hc_strtoul (optarg, NULL, 10); user_options->stdin_timeout_abort_chgd = true; break; case IDX_SPEED_ONLY: user_options->speed_only = true; break; case IDX_PROGRESS_ONLY: user_options->progress_only = true; break; case IDX_RESTORE_DISABLE: user_options->restore_disable = true; break; case IDX_RESTORE_FILE_PATH: user_options->restore_file_path = optarg; break; case IDX_STATUS: user_options->status = true; break; case IDX_STATUS_JSON: user_options->status_json = true; break; case IDX_STATUS_TIMER: user_options->status_timer = hc_strtoul (optarg, NULL, 10); break; case IDX_MACHINE_READABLE: user_options->machine_readable = true; break; case IDX_LOOPBACK: user_options->loopback = true; break; case IDX_SESSION: user_options->session = optarg; break; case IDX_HASH_MODE: user_options->hash_mode = hc_strtoul (optarg, NULL, 10); user_options->hash_mode_chgd = true; break; case IDX_RUNTIME: user_options->runtime = hc_strtoul (optarg, NULL, 10); user_options->runtime_chgd = true; break; case IDX_ATTACK_MODE: user_options->attack_mode = hc_strtoul (optarg, NULL, 10); user_options->attack_mode_chgd = true; break; case IDX_RP_FILE: user_options->rp_files[user_options->rp_files_cnt++] = optarg; break; case IDX_RP_GEN: user_options->rp_gen = hc_strtoul (optarg, NULL, 10); break; case IDX_RP_GEN_FUNC_MIN: user_options->rp_gen_func_min = hc_strtoul (optarg, NULL, 10); break; case IDX_RP_GEN_FUNC_MAX: user_options->rp_gen_func_max = hc_strtoul (optarg, NULL, 10); break; case IDX_RP_GEN_SEED: user_options->rp_gen_seed = hc_strtoul (optarg, NULL, 10); user_options->rp_gen_seed_chgd = true; break; case IDX_RULE_BUF_L: user_options->rule_buf_l = optarg; break; case IDX_RULE_BUF_R: user_options->rule_buf_r = optarg; break; case IDX_MARKOV_DISABLE: user_options->markov_disable = true; break; case IDX_MARKOV_CLASSIC: user_options->markov_classic = true; break; case IDX_MARKOV_THRESHOLD: user_options->markov_threshold = hc_strtoul (optarg, NULL, 10); break; case IDX_MARKOV_HCSTAT2: user_options->markov_hcstat2 = optarg; break; case IDX_OUTFILE: user_options->outfile = optarg; break; case IDX_OUTFILE_FORMAT: user_options->outfile_format = outfile_format_parse (optarg); user_options->outfile_format_chgd = true; break; case IDX_OUTFILE_AUTOHEX_DISABLE: user_options->outfile_autohex = false; break; case IDX_OUTFILE_CHECK_TIMER: user_options->outfile_check_timer = hc_strtoul (optarg, NULL, 10); break; case IDX_WORDLIST_AUTOHEX_DISABLE: user_options->wordlist_autohex_disable = true; break; case IDX_HEX_CHARSET: user_options->hex_charset = true; break; case IDX_HEX_SALT: user_options->hex_salt = true; break; case IDX_HEX_WORDLIST: user_options->hex_wordlist = true; break; case IDX_CPU_AFFINITY: user_options->cpu_affinity = optarg; break; case IDX_BACKEND_IGNORE_CUDA: user_options->backend_ignore_cuda = true; break; case IDX_BACKEND_IGNORE_OPENCL: user_options->backend_ignore_opencl = true; break; case IDX_BACKEND_INFO: user_options->backend_info = true; break; case IDX_BACKEND_DEVICES: user_options->backend_devices = optarg; break; case IDX_BACKEND_VECTOR_WIDTH: user_options->backend_vector_width = hc_strtoul (optarg, NULL, 10); user_options->backend_vector_width_chgd = true; break; case IDX_OPENCL_DEVICE_TYPES: user_options->opencl_device_types = optarg; break; case IDX_OPTIMIZED_KERNEL_ENABLE: user_options->optimized_kernel_enable = true; break; case IDX_WORKLOAD_PROFILE: user_options->workload_profile = hc_strtoul (optarg, NULL, 10); user_options->workload_profile_chgd = true; break; case IDX_KERNEL_ACCEL: user_options->kernel_accel = hc_strtoul (optarg, NULL, 10); user_options->kernel_accel_chgd = true; break; case IDX_KERNEL_LOOPS: user_options->kernel_loops = hc_strtoul (optarg, NULL, 10); user_options->kernel_loops_chgd = true; break; case IDX_KERNEL_THREADS: user_options->kernel_threads = hc_strtoul (optarg, NULL, 10); user_options->kernel_threads_chgd = true; break; case IDX_SPIN_DAMP: user_options->spin_damp = hc_strtoul (optarg, NULL, 10); user_options->spin_damp_chgd = true; break; case IDX_HWMON_DISABLE: user_options->hwmon_disable = true; break; case IDX_HWMON_TEMP_ABORT: user_options->hwmon_temp_abort = hc_strtoul (optarg, NULL, 10); break; case IDX_LOGFILE_DISABLE: user_options->logfile_disable = true; break; case IDX_HCCAPX_MESSAGE_PAIR: user_options->hccapx_message_pair = hc_strtoul (optarg, NULL, 10); user_options->hccapx_message_pair_chgd = true; break; case IDX_NONCE_ERROR_CORRECTIONS: user_options->nonce_error_corrections = hc_strtoul (optarg, NULL, 10); user_options->nonce_error_corrections_chgd = true; break; case IDX_KEYBOARD_LAYOUT_MAPPING: user_options->keyboard_layout_mapping = optarg; break; case IDX_TRUECRYPT_KEYFILES: user_options->truecrypt_keyfiles = optarg; break; case IDX_VERACRYPT_KEYFILES: user_options->veracrypt_keyfiles = optarg; break; case IDX_VERACRYPT_PIM_START: user_options->veracrypt_pim_start = hc_strtoul (optarg, NULL, 10); user_options->veracrypt_pim_start_chgd = true; break; case IDX_VERACRYPT_PIM_STOP: user_options->veracrypt_pim_stop = hc_strtoul (optarg, NULL, 10); user_options->veracrypt_pim_stop_chgd = true; break; case IDX_SEGMENT_SIZE: user_options->segment_size = hc_strtoul (optarg, NULL, 10); user_options->segment_size_chgd = true; break; case IDX_SCRYPT_TMTO: user_options->scrypt_tmto = hc_strtoul (optarg, NULL, 10); user_options->scrypt_tmto_chgd = true; break; case IDX_SEPARATOR: user_options->separator = optarg[0]; break; case IDX_BITMAP_MIN: user_options->bitmap_min = hc_strtoul (optarg, NULL, 10); break; case IDX_BITMAP_MAX: user_options->bitmap_max = hc_strtoul (optarg, NULL, 10); break; case IDX_HOOK_THREADS: user_options->hook_threads = hc_strtoul (optarg, NULL, 10); break; case IDX_INCREMENT: user_options->increment = true; break; case IDX_INCREMENT_MIN: user_options->increment_min = hc_strtoul (optarg, NULL, 10); user_options->increment_min_chgd = true; break; case IDX_INCREMENT_MAX: user_options->increment_max = hc_strtoul (optarg, NULL, 10); user_options->increment_max_chgd = true; break; case IDX_CUSTOM_CHARSET_1: user_options->custom_charset_1 = optarg; break; case IDX_CUSTOM_CHARSET_2: user_options->custom_charset_2 = optarg; break; case IDX_CUSTOM_CHARSET_3: user_options->custom_charset_3 = optarg; break; case IDX_CUSTOM_CHARSET_4: user_options->custom_charset_4 = optarg; break; case IDX_SLOW_CANDIDATES: user_options->slow_candidates = true; break; #ifdef WITH_BRAIN case IDX_BRAIN_CLIENT: user_options->brain_client = true; break; case IDX_BRAIN_CLIENT_FEATURES: user_options->brain_client_features = hc_strtoul (optarg, NULL, 10); break; case IDX_BRAIN_SERVER: user_options->brain_server = true; break; case IDX_BRAIN_SERVER_TIMER: user_options->brain_server_timer = hc_strtoul (optarg, NULL, 10); user_options->brain_server_timer_chgd = true; break; case IDX_BRAIN_PASSWORD: user_options->brain_password = optarg; user_options->brain_password_chgd = true; break; case IDX_BRAIN_HOST: user_options->brain_host = optarg; user_options->brain_host_chgd = true; break; case IDX_BRAIN_PORT: user_options->brain_port = hc_strtoul (optarg, NULL, 10); user_options->brain_port_chgd = true; break; case IDX_BRAIN_SESSION: user_options->brain_session = hc_strtoul (optarg, NULL, 16); break; case IDX_BRAIN_SESSION_WHITELIST: user_options->brain_session_whitelist = optarg; break; #endif } } user_options->hc_bin = argv[0]; user_options->hc_argc = argc - optind; user_options->hc_argv = argv + optind; return 0; } int user_options_sanity (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; if (user_options->hc_argc < 0) { event_log_error (hashcat_ctx, "hc_argc %d is invalid.", user_options->hc_argc); return -1; } if (user_options->hc_argv == NULL) { event_log_error (hashcat_ctx, "hc_argv is NULL."); return -1; } #ifdef WITH_BRAIN if ((user_options->brain_client == true) && (user_options->brain_server == true)) { event_log_error (hashcat_ctx, "Can not have --brain-client and --brain-server at the same time"); return -1; } if ((user_options->brain_client_features < 1) || (user_options->brain_client_features > 3)) { event_log_error (hashcat_ctx, "Invalid --brain-client-feature argument"); return -1; } if ((user_options->brain_client == true) && (user_options->brain_password_chgd == false)) { event_log_error (hashcat_ctx, "Brain clients need to set --brain-password"); return -1; } if (user_options->brain_server_timer_chgd) { if (user_options->brain_server == false) { event_log_error (hashcat_ctx, "The --brain-server-timer flag requires --brain-server."); return -1; } if (user_options->brain_server_timer != 0) // special case (no intermediate dumps) { if (user_options->brain_server_timer < 60) { event_log_error (hashcat_ctx, "Brain server backup timer must be at least 60 seconds."); return -1; } } } #endif if (user_options->slow_candidates == true) { if ((user_options->attack_mode != ATTACK_MODE_STRAIGHT) && (user_options->attack_mode != ATTACK_MODE_COMBI) && (user_options->attack_mode != ATTACK_MODE_BF)) { event_log_error (hashcat_ctx, "Invalid attack mode (-a) value specified in slow-candidates mode."); return -1; } } #ifdef WITH_BRAIN else if (user_options->brain_client == true) { if ((user_options->attack_mode != ATTACK_MODE_STRAIGHT) && (user_options->attack_mode != ATTACK_MODE_COMBI) && (user_options->attack_mode != ATTACK_MODE_BF)) { event_log_error (hashcat_ctx, "Invalid attack mode (-a) value specified in brain-client mode."); return -1; } } #endif else { if ((user_options->attack_mode != ATTACK_MODE_STRAIGHT) && (user_options->attack_mode != ATTACK_MODE_COMBI) && (user_options->attack_mode != ATTACK_MODE_BF) && (user_options->attack_mode != ATTACK_MODE_HYBRID1) && (user_options->attack_mode != ATTACK_MODE_HYBRID2) && (user_options->attack_mode != ATTACK_MODE_ASSOCIATION) && (user_options->attack_mode != ATTACK_MODE_NONE)) { event_log_error (hashcat_ctx, "Invalid attack mode (-a) value specified."); return -1; } } if (user_options->hccapx_message_pair_chgd == true) { if (user_options->remove == true) { event_log_error (hashcat_ctx, "Combining --remove with --hccapx-message-pair is not allowed."); return -1; } if (user_options->hccapx_message_pair >= 6) { event_log_error (hashcat_ctx, "Invalid --hccapx-message-pair value specified."); return -1; } } /* if (user_options->skip_chgd == true && user_options->skip == 0) { event_log_error (hashcat_ctx, "Invalid --skip value specified."); return -1; } */ if (user_options->limit_chgd == true && user_options->limit == 0) { event_log_error (hashcat_ctx, "Invalid --limit value specified."); return -1; } if (user_options->runtime_chgd == true && user_options->runtime == 0) { event_log_error (hashcat_ctx, "Invalid --runtime value specified."); return -1; } if (user_options->runtime_chgd == true && user_options->loopback == true) { event_log_error (hashcat_ctx, "Combining --limit with --loopback is not allowed."); return -1; } if (user_options->hash_mode >= MODULE_HASH_MODES_MAXIMUM) { event_log_error (hashcat_ctx, "Invalid -m (hash type) value specified."); return -1; } if (user_options->outfile_format == 0) { event_log_error (hashcat_ctx, "Invalid --outfile-format value specified."); return -1; } if (user_options->left == true) { if (user_options->outfile_format_chgd == true) { if (user_options->outfile_format > 1) { event_log_error (hashcat_ctx, "Combining --outfile-format > 1 with --left is not allowed."); return -1; } } } if (user_options->show == true) { if (user_options->outfile_format_chgd == true) { if (user_options->outfile_format & OUTFILE_FMT_CRACKPOS) { event_log_error (hashcat_ctx, "Using crack_pos in --outfile-format for --show is not allowed."); return -1; } if (user_options->outfile_format & OUTFILE_FMT_TIME_ABS) { event_log_error (hashcat_ctx, "Using the absolute timestamp in --outfile-format for --show is not allowed."); return -1; } if (user_options->outfile_format & OUTFILE_FMT_TIME_REL) { event_log_error (hashcat_ctx, "Using the relative timestamp in --outfile-format for --show is not allowed."); return -1; } } } if (user_options->increment_min < INCREMENT_MIN) { event_log_error (hashcat_ctx, "Invalid --increment-min value specified."); return -1; } if (user_options->increment_max > INCREMENT_MAX) { event_log_error (hashcat_ctx, "Invalid --increment-max value specified."); return -1; } if ((user_options->veracrypt_pim_start_chgd == true) && (user_options->veracrypt_pim_stop_chgd == false)) { event_log_error (hashcat_ctx, "If --veracrypt-pim-start is specified then --veracrypt-pim-stop needs to be specified, too."); return -1; } if ((user_options->veracrypt_pim_start_chgd == false) && (user_options->veracrypt_pim_stop_chgd == true)) { event_log_error (hashcat_ctx, "If --veracrypt-pim-stop is specified then --veracrypt-pim-start needs to be specified, too."); return -1; } if (user_options->veracrypt_pim_start > user_options->veracrypt_pim_stop) { event_log_error (hashcat_ctx, "Invalid --veracrypt-pim-start value specified."); return -1; } if (user_options->increment_min > user_options->increment_max) { event_log_error (hashcat_ctx, "Invalid --increment-min value specified - must be >= --increment-max."); return -1; } if ((user_options->increment == true) && (user_options->progress_only == true)) { event_log_error (hashcat_ctx, "Increment is not allowed in combination with --progress-only."); return -1; } if ((user_options->increment == true) && (user_options->speed_only == true)) { event_log_error (hashcat_ctx, "Increment is not allowed in combination with --speed-only."); return -1; } if ((user_options->increment == true) && (user_options->attack_mode == ATTACK_MODE_STRAIGHT)) { event_log_error (hashcat_ctx, "Increment is not allowed in attack mode 0 (straight)."); return -1; } if ((user_options->increment == true) && (user_options->attack_mode == ATTACK_MODE_ASSOCIATION)) { event_log_error (hashcat_ctx, "Increment is not allowed in attack mode 9 (association)."); return -1; } if ((user_options->remove == true) && (user_options->attack_mode == ATTACK_MODE_ASSOCIATION)) { event_log_error (hashcat_ctx, "Remove is not allowed in attack mode 9 (association)."); return -1; } if ((user_options->increment == false) && (user_options->increment_min_chgd == true)) { event_log_error (hashcat_ctx, "Increment-min is only supported when combined with -i/--increment."); return -1; } if ((user_options->increment == false) && (user_options->increment_max_chgd == true)) { event_log_error (hashcat_ctx, "Increment-max is only supported combined with -i/--increment."); return -1; } if ((user_options->rp_files_cnt > 0) && (user_options->rp_gen > 0)) { event_log_error (hashcat_ctx, "Combining -r/--rules-file and -g/--rules-generate is not supported."); return -1; } if ((user_options->rp_files_cnt > 0) || (user_options->rp_gen > 0)) { if ((user_options->attack_mode != ATTACK_MODE_STRAIGHT) && (user_options->attack_mode != ATTACK_MODE_ASSOCIATION)) { event_log_error (hashcat_ctx, "Use of -r/--rules-file and -g/--rules-generate only allowed in attack mode 0 or 9."); return -1; } } if (user_options->bitmap_min > user_options->bitmap_max) { event_log_error (hashcat_ctx, "Invalid --bitmap-min value specified."); return -1; } if (user_options->rp_gen_func_min > user_options->rp_gen_func_max) { event_log_error (hashcat_ctx, "Invalid --rp-gen-func-min value specified."); return -1; } if (user_options->kernel_accel_chgd == true) { if (user_options->force == false) { event_log_error (hashcat_ctx, "The manual use of the -n option (or --kernel-accel) is outdated."); event_log_warning (hashcat_ctx, "Please consider using the -w option instead."); 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 -1; } if (user_options->kernel_accel < 1) { event_log_error (hashcat_ctx, "Invalid --kernel-accel value specified - must be greater than 0."); return -1; } if (user_options->kernel_accel > 1024) { event_log_error (hashcat_ctx, "Invalid --kernel-accel value specified - must be <= 1024."); return -1; } } if (user_options->kernel_loops_chgd == true) { if (user_options->force == false) { event_log_error (hashcat_ctx, "The manual use of the -u option (or --kernel-loops) is outdated."); event_log_warning (hashcat_ctx, "Please consider using the -w option instead."); 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 -1; } if (user_options->kernel_loops < 1) { event_log_error (hashcat_ctx, "Invalid kernel-loops specified."); return -1; } if (user_options->kernel_loops > 1024) { event_log_error (hashcat_ctx, "Invalid kernel-loops specified."); return -1; } } if (user_options->kernel_threads_chgd == true) { if (user_options->force == false) { event_log_error (hashcat_ctx, "The manual use of the -T option (or --kernel-threads) is outdated."); 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 -1; } if (user_options->kernel_threads < 1) { event_log_error (hashcat_ctx, "Invalid kernel-threads specified."); return -1; } if (user_options->kernel_threads > 1024) { event_log_error (hashcat_ctx, "Invalid kernel-threads specified."); return -1; } } if ((user_options->workload_profile < 1) || (user_options->workload_profile > 4)) { event_log_error (hashcat_ctx, "workload-profile %u is not available.", user_options->workload_profile); return -1; } if (user_options->backend_vector_width_chgd == true) { if (is_power_of_2 (user_options->backend_vector_width) == false || user_options->backend_vector_width > 16) { event_log_error (hashcat_ctx, "backend-vector-width %u is not allowed.", user_options->backend_vector_width); return -1; } } if (user_options->show == true || user_options->left == true) { if (user_options->remove == true) { event_log_error (hashcat_ctx, "Mixing --remove not allowed with --show or --left."); return -1; } if (user_options->potfile_disable == true) { event_log_error (hashcat_ctx, "Mixing --potfile-disable is not allowed with --show or --left."); return -1; } } if (user_options->show == true) { if (user_options->outfile_autohex == false) { event_log_error (hashcat_ctx, "Mixing --outfile-autohex-disable is not allowed with --show."); return -1; } } if (user_options->keyspace == true) { if (user_options->show == true) { event_log_error (hashcat_ctx, "Combining --show with --keyspace is not allowed."); return -1; } if (user_options->left == true) { event_log_error (hashcat_ctx, "Combining --left with --keyspace is not allowed."); return -1; } } if (user_options->machine_readable == true) { if (user_options->status_json == true) { event_log_error (hashcat_ctx, "The --status-json flag can not be used with --machine-readable."); return -1; } } if (user_options->remove_timer_chgd == true) { if (user_options->remove == false) { event_log_error (hashcat_ctx, "The --remove-timer flag requires --remove."); return -1; } if (user_options->remove_timer < 1) { event_log_error (hashcat_ctx, "The --remove-timer parameter must have a value greater than or equal to 1."); return -1; } } if (user_options->loopback == true) { if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { if ((user_options->rp_files_cnt == 0) && (user_options->rp_gen == 0)) { event_log_error (hashcat_ctx, "Parameter --loopback not allowed without -r/--rules-file or -g/--rules-generate."); return -1; } } else { event_log_error (hashcat_ctx, "Parameter --loopback is only allowed in attack mode 0 (straight)."); return -1; } } if (user_options->debug_mode > 0) { if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) { event_log_error (hashcat_ctx, "Parameter --debug-mode option is only allowed in attack mode 0 (straight)."); return -1; } if ((user_options->rp_files_cnt == 0) && (user_options->rp_gen == 0)) { event_log_error (hashcat_ctx, "Use of --debug-mode requires -r/--rules-file or -g/--rules-generate."); return -1; } } if (user_options->debug_mode > 4) { event_log_error (hashcat_ctx, "Invalid --debug-mode value specified."); return -1; } if (user_options->debug_file != NULL) { if (user_options->debug_mode < 1) { event_log_error (hashcat_ctx, "Parameter --debug-file requires --debug-mode."); return -1; } } if (user_options->induction_dir != NULL) { if (user_options->attack_mode == ATTACK_MODE_BF) { event_log_error (hashcat_ctx, "Use of --induction-dir is not allowed in attack mode 3 (brute-force)."); return -1; } if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { event_log_error (hashcat_ctx, "Use of --induction-dir is not allowed in attack mode 9 (association)."); return -1; } } if (user_options->spin_damp > 100) { event_log_error (hashcat_ctx, "Values of --spin-damp must be between 0 and 100 (inclusive)."); return -1; } if (user_options->benchmark == true) { // sanity checks based on automatically overwritten configuration variables by // benchmark mode section in user_options_preprocess() #ifdef WITH_BRAIN if (user_options->brain_client == true) { event_log_error (hashcat_ctx, "Brain client (-z) is not allowed in benchmark mode."); return -1; } if (user_options->brain_server == true) { event_log_error (hashcat_ctx, "Brain server is not allowed in benchmark mode."); return -1; } #endif if (user_options->attack_mode_chgd == true) { event_log_error (hashcat_ctx, "Can't change --attack-mode (-a) in benchmark mode."); return -1; } if (user_options->bitmap_min != BITMAP_MIN) { event_log_error (hashcat_ctx, "Can't change --bitmap-min in benchmark mode."); return -1; } if (user_options->bitmap_max != BITMAP_MAX) { event_log_error (hashcat_ctx, "Can't change --bitmap-max in benchmark mode."); return -1; } if (user_options->hwmon_temp_abort != HWMON_TEMP_ABORT) { event_log_error (hashcat_ctx, "Can't change --hwmon-temp-abort in benchmark mode."); return -1; } if (user_options->left == true) { event_log_error (hashcat_ctx, "Can't change --left in benchmark mode."); return -1; } if (user_options->show == true) { event_log_error (hashcat_ctx, "Can't change --show in benchmark mode."); return -1; } if (user_options->speed_only == true) { event_log_error (hashcat_ctx, "Can't change --speed-only in benchmark mode."); return -1; } if (user_options->progress_only == true) { event_log_error (hashcat_ctx, "Can't change --progress-only in benchmark mode."); return -1; } if (user_options->increment == true) { event_log_error (hashcat_ctx, "Can't change --increment (-i) in benchmark mode."); return -1; } if (user_options->restore == true) { event_log_error (hashcat_ctx, "Can't change --restore in benchmark mode."); return -1; } if (user_options->status == true) { event_log_error (hashcat_ctx, "Can't change --status in benchmark mode."); return -1; } if (user_options->spin_damp_chgd == true) { event_log_error (hashcat_ctx, "Can't change --spin-damp in benchmark mode."); return -1; } if ((user_options->custom_charset_1 != NULL) || (user_options->custom_charset_2 != NULL) || (user_options->custom_charset_3 != NULL) || (user_options->custom_charset_4 != NULL)) { if ((user_options->attack_mode == ATTACK_MODE_STRAIGHT) || (user_options->attack_mode == ATTACK_MODE_ASSOCIATION)) { event_log_error (hashcat_ctx, "Custom charsets are not supported in benchmark mode."); return -1; } } } if (user_options->markov_hcstat2 != NULL) { if (strlen (user_options->markov_hcstat2) == 0) { event_log_error (hashcat_ctx, "Invalid --markov-hcstat2 value - must not be empty."); return -1; } } if (user_options->restore_file_path != NULL) { if (strlen (user_options->restore_file_path) == 0) { event_log_error (hashcat_ctx, "Invalid --restore-file-path value - must not be empty."); return -1; } } if (user_options->outfile != NULL) { if (strlen (user_options->outfile) == 0) { event_log_error (hashcat_ctx, "Invalid --outfile value - must not be empty."); return -1; } } if (user_options->debug_file != NULL) { if (strlen (user_options->debug_file) == 0) { event_log_error (hashcat_ctx, "Invalid --debug-file value - must not be empty."); return -1; } } if (user_options->session != NULL) { if (strlen (user_options->session) == 0) { event_log_error (hashcat_ctx, "Invalid --session value - must not be empty."); return -1; } } if (user_options->cpu_affinity != NULL) { if (strlen (user_options->cpu_affinity) == 0) { event_log_error (hashcat_ctx, "Invalid --cpu-affinity value - must not be empty."); return -1; } } if (user_options->backend_devices != NULL) { if (strlen (user_options->backend_devices) == 0) { event_log_error (hashcat_ctx, "Invalid --backend-devices value - must not be empty."); return -1; } } if (user_options->opencl_device_types != NULL) { if (strlen (user_options->opencl_device_types) == 0) { event_log_error (hashcat_ctx, "Invalid --opencl-device-types value - must not be empty."); return -1; } } if (user_options->stdin_timeout_abort_chgd == true) { if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) { event_log_error (hashcat_ctx, "Use of --stdin-timeout-abort is only allowed in attack mode 0 (straight)."); return -1; } // --stdin-timeout-abort can only be used in stdin mode if (user_options->hc_argc != 1) { event_log_error (hashcat_ctx, "Use of --stdin-timeout-abort is only allowed in stdin mode (pipe)."); return -1; } } #ifdef WITH_BRAIN if ((user_options->brain_client == true) && (user_options->remove == true)) { event_log_error (hashcat_ctx, "Using --remove is not allowed if --brain-client is used."); return -1; } if ((user_options->brain_client == true) && (user_options->potfile_disable == true)) { event_log_error (hashcat_ctx, "Using --potfile-disable is not allowed if --brain-client is used."); return -1; } #endif // custom charset checks if ((user_options->custom_charset_1 != NULL) || (user_options->custom_charset_2 != NULL) || (user_options->custom_charset_3 != NULL) || (user_options->custom_charset_4 != NULL)) { if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { event_log_error (hashcat_ctx, "Custom charsets are not supported in attack mode 0 (straight)."); return -1; } if (user_options->attack_mode == ATTACK_MODE_COMBI) { event_log_error (hashcat_ctx, "Custom charsets are not supported in attack mode 1 (combination)."); return -1; } if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { event_log_error (hashcat_ctx, "Custom charsets are not supported in attack mode 9 (association)."); return -1; } // detect if mask was specified: bool mask_is_missing = true; if (user_options->keyspace == true) // special case if --keyspace was used: we need the mask but no hash file { if (user_options->hc_argc > 0) mask_is_missing = false; } else if (user_options->stdout_flag == true) // special case if --stdout was used: we need the mask but no hash file { if (user_options->hc_argc > 0) mask_is_missing = false; } else { if (user_options->hc_argc > 1) mask_is_missing = false; } if (mask_is_missing == true) { event_log_error (hashcat_ctx, "If you specify a custom charset, you must also specify a mask."); return -1; } } // argc / argv checks bool show_error = true; if (user_options->version == true) { show_error = false; } else if (user_options->usage == true) { show_error = false; } #ifdef WITH_BRAIN else if (user_options->brain_server == true) { show_error = false; } #endif else if (user_options->benchmark == true) { if (user_options->hc_argc == 0) { show_error = false; } } else if (user_options->hash_info == true) { if (user_options->hc_argc == 0) { show_error = false; } } else if (user_options->backend_info == true) { if (user_options->hc_argc == 0) { show_error = false; } } else if (user_options->restore == true) { if (user_options->hc_argc == 0) { show_error = false; } } else if (user_options->keyspace == true) { if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { if (user_options->hc_argc == 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { if (user_options->hc_argc == 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_BF) { if (user_options->hc_argc == 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { if (user_options->hc_argc == 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { if (user_options->hc_argc == 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { if (user_options->hc_argc == 1) { show_error = false; } } } else if (user_options->stdout_flag == true) { if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { // all argc possible because of stdin mode show_error = false; } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { if (user_options->hc_argc == 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_BF) { if (user_options->hc_argc >= 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { if (user_options->hc_argc >= 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { if (user_options->hc_argc >= 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { if (user_options->hc_argc >= 1) { show_error = false; } } } else { if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { if (user_options->hc_argc >= 1) { show_error = false; } if (user_options->hc_argc == 1) { // stdin mode #ifdef WITH_BRAIN if (user_options->brain_client == true) { event_log_error (hashcat_ctx, "Use of --brain-client is not possible in stdin mode."); return -1; } #endif if (user_options->slow_candidates == true) { event_log_error (hashcat_ctx, "Use of --slow-candidates is not possible in stdin mode."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { if (user_options->hc_argc == 3) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_BF) { if (user_options->hc_argc >= 1) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { if (user_options->hc_argc >= 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { if (user_options->hc_argc >= 2) { show_error = false; } } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { if (user_options->hc_argc >= 2) { show_error = false; } } } if (show_error == true) { usage_mini_print (user_options->hc_bin); return -1; } return 0; } void user_options_session_auto (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; if (strcmp (user_options->session, PROGNAME) == 0) { if (user_options->benchmark == true) { user_options->session = "benchmark"; } if (user_options->hash_info == true) { user_options->session = "hash_info"; } if (user_options->usage == true) { user_options->session = "usage"; } if (user_options->speed_only == true) { user_options->session = "speed_only"; } if (user_options->progress_only == true) { user_options->session = "progress_only"; } if (user_options->keyspace == true) { user_options->session = "keyspace"; } if (user_options->stdout_flag == true) { user_options->session = "stdout"; } if (user_options->backend_info == true) { user_options->session = "backend_info"; } if (user_options->show == true) { user_options->session = "show"; } if (user_options->left == true) { user_options->session = "left"; } } } void user_options_preprocess (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; // some options can influence or overwrite other options #ifdef WITH_BRAIN if (user_options->brain_client == true) { user_options->slow_candidates = true; } #endif if (user_options->stdout_flag) { user_options->hwmon_disable = true; user_options->left = false; user_options->logfile_disable = true; user_options->spin_damp = 0; user_options->outfile_check_timer = 0; user_options->potfile_disable = true; user_options->restore_disable = true; user_options->restore = false; user_options->restore_timer = 0; user_options->show = false; user_options->status = false; user_options->status_timer = 0; user_options->bitmap_min = 1; user_options->bitmap_max = 1; } if (user_options->hash_info == true || user_options->backend_info == true || user_options->keyspace == true || user_options->speed_only == true || user_options->progress_only == true || user_options->usage == true) { user_options->hwmon_disable = true; user_options->left = false; user_options->logfile_disable = true; user_options->spin_damp = 0; user_options->outfile_check_timer = 0; user_options->potfile_disable = true; user_options->restore_disable = true; user_options->restore = false; user_options->restore_timer = 0; user_options->show = false; user_options->status = false; user_options->status_timer = 0; user_options->bitmap_min = 1; user_options->bitmap_max = 1; #ifdef WITH_BRAIN user_options->brain_client = false; #endif } if (user_options->benchmark == true) { user_options->attack_mode = ATTACK_MODE_BF; user_options->hwmon_temp_abort = 0; user_options->increment = false; user_options->left = false; user_options->logfile_disable = true; user_options->spin_damp = 0; user_options->potfile_disable = true; user_options->progress_only = false; user_options->restore_disable = true; user_options->restore = false; user_options->restore_timer = 0; user_options->show = false; user_options->speed_only = true; user_options->status = false; user_options->status_timer = 0; user_options->bitmap_min = 1; user_options->bitmap_max = 1; #ifdef WITH_BRAIN user_options->brain_client = false; #endif if (user_options->workload_profile_chgd == false) { user_options->optimized_kernel_enable = true; user_options->workload_profile = 3; } } if (user_options->hash_info == true) { user_options->quiet = true; } if (user_options->usage == true) { user_options->quiet = true; } if (user_options->progress_only == true) { user_options->speed_only = true; } if (user_options->keyspace == true) { user_options->quiet = true; } if (user_options->slow_candidates == true) { user_options->backend_vector_width = 1; } if (user_options->stdout_flag == true) { user_options->force = true; user_options->hash_mode = 2000; user_options->kernel_accel = 1024; user_options->backend_vector_width = 1; user_options->outfile_format = OUTFILE_FMT_PLAIN; user_options->quiet = true; if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { user_options->kernel_loops = KERNEL_RULES; } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { user_options->kernel_loops = KERNEL_COMBS; } else if (user_options->attack_mode == ATTACK_MODE_BF) { user_options->kernel_loops = KERNEL_BFS; } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { user_options->kernel_loops = KERNEL_COMBS; } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { user_options->kernel_loops = KERNEL_COMBS; } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { user_options->kernel_loops = KERNEL_RULES; } } if (user_options->backend_info == true) { user_options->backend_devices = NULL; user_options->opencl_device_types = hcstrdup ("1,2,3"); user_options->quiet = true; } if (user_options->left == true) { user_options->outfile_format = OUTFILE_FMT_HASH; } if (user_options->show == true || user_options->left == true) { user_options->attack_mode = ATTACK_MODE_NONE; user_options->quiet = true; } // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running) if (user_options->show == true || user_options->left == true) { user_options->restore_disable = true; user_options->restore = false; } if (user_options->skip != 0 && user_options->limit != 0) { user_options->limit += user_options->skip; } if (user_options->markov_threshold == 0) { user_options->markov_threshold = 0x100; } if (user_options->segment_size_chgd == true) { user_options->segment_size *= (1024 * 1024); } #if !defined (WITH_HWMON) user_options->hwmon_disable = true; #endif // WITH_HWMON if (user_options->hwmon_disable == true) { user_options->hwmon_temp_abort = 0; } // default mask if (user_options->attack_mode == ATTACK_MODE_BF) { if (user_options->hash_info == true) { } else if (user_options->backend_info == true) { } else if (user_options->speed_only == true) { } else if (user_options->keyspace == true) { if (user_options->hc_argc == 0) { user_options->custom_charset_1 = DEF_MASK_CS_1; user_options->custom_charset_2 = DEF_MASK_CS_2; user_options->custom_charset_3 = DEF_MASK_CS_3; user_options->increment = true; } } else if (user_options->stdout_flag == true) { if (user_options->hc_argc == 0) { user_options->custom_charset_1 = DEF_MASK_CS_1; user_options->custom_charset_2 = DEF_MASK_CS_2; user_options->custom_charset_3 = DEF_MASK_CS_3; user_options->increment = true; } } else { if (user_options->hc_argc == 1) { user_options->custom_charset_1 = DEF_MASK_CS_1; user_options->custom_charset_2 = DEF_MASK_CS_2; user_options->custom_charset_3 = DEF_MASK_CS_3; user_options->increment = true; } } } // association limitations if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { user_options->potfile_disable = true; } if (user_options->stdout_flag == false && user_options->benchmark == false && user_options->keyspace == false) { if (user_options->hash_mode == 0 && user_options->hash_mode_chgd == false) { user_options->autodetect = true; } } } void user_options_postprocess (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; // automatic status if (user_options_extra->wordlist_mode == WL_MODE_STDIN) { user_options->status = true; } } void user_options_info (hashcat_ctx_t *hashcat_ctx) { const user_options_t *user_options = hashcat_ctx->user_options; if (user_options->quiet == true) return; if (user_options->benchmark == false) return; if (user_options->machine_readable == false) { event_log_info (hashcat_ctx, "Benchmark relevant options:"); event_log_info (hashcat_ctx, "==========================="); if (user_options->benchmark_all == true) { event_log_info (hashcat_ctx, "* --benchmark-all"); } if (user_options->force == true) { event_log_info (hashcat_ctx, "* --force"); } if (user_options->backend_devices) { event_log_info (hashcat_ctx, "* --backend-devices=%s", user_options->backend_devices); } if (user_options->opencl_device_types) { event_log_info (hashcat_ctx, "* --opencl-device-types=%s", user_options->opencl_device_types); } if (user_options->optimized_kernel_enable == true) { event_log_info (hashcat_ctx, "* --optimized-kernel-enable"); } if (user_options->backend_vector_width_chgd == true) { event_log_info (hashcat_ctx, "* --backend-vector-width=%u", user_options->backend_vector_width); } if (user_options->kernel_accel_chgd == true) { event_log_info (hashcat_ctx, "* --kernel-accel=%u", user_options->kernel_accel); } else if (user_options->kernel_loops_chgd == true) { event_log_info (hashcat_ctx, "* --kernel-loops=%u", user_options->kernel_loops); } else if (user_options->kernel_threads_chgd == true) { event_log_info (hashcat_ctx, "* --kernel-threads=%u", user_options->kernel_threads); } else { if (user_options->workload_profile_chgd == true) { event_log_info (hashcat_ctx, "* --workload-profile=%u", user_options->workload_profile); } } event_log_info (hashcat_ctx, NULL); } else { if (user_options->benchmark_all == true) { event_log_info (hashcat_ctx, "# option: --benchmark-all"); } if (user_options->force == true) { event_log_info (hashcat_ctx, "# option: --force"); } if (user_options->backend_devices) { event_log_info (hashcat_ctx, "# option: --backend-devices=%s", user_options->backend_devices); } if (user_options->opencl_device_types) { event_log_info (hashcat_ctx, "# option: --opencl-device-types=%s", user_options->opencl_device_types); } if (user_options->optimized_kernel_enable == true) { event_log_info (hashcat_ctx, "# option: --optimized-kernel-enable"); } if (user_options->backend_vector_width_chgd == true) { event_log_info (hashcat_ctx, "# option: --backend-vector-width=%u", user_options->backend_vector_width); } if (user_options->kernel_accel_chgd == true) { event_log_info (hashcat_ctx, "# option: --kernel-accel=%u", user_options->kernel_accel); } else if (user_options->kernel_loops_chgd == true) { event_log_info (hashcat_ctx, "# option: --kernel-loops=%u", user_options->kernel_loops); } else if (user_options->kernel_threads_chgd == true) { event_log_info (hashcat_ctx, "# option: --kernel-threads=%u", user_options->kernel_threads); } else { if (user_options->workload_profile_chgd == true) { event_log_info (hashcat_ctx, "# option: --workload-profile=%u", user_options->workload_profile); } } } } void user_options_extra_init (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; // attack-kern user_options_extra->attack_kern = ATTACK_KERN_NONE; switch (user_options->attack_mode) { case ATTACK_MODE_STRAIGHT: user_options_extra->attack_kern = ATTACK_KERN_STRAIGHT; break; case ATTACK_MODE_COMBI: user_options_extra->attack_kern = ATTACK_KERN_COMBI; break; case ATTACK_MODE_BF: user_options_extra->attack_kern = ATTACK_KERN_BF; break; case ATTACK_MODE_HYBRID1: user_options_extra->attack_kern = ATTACK_KERN_COMBI; break; case ATTACK_MODE_HYBRID2: user_options_extra->attack_kern = ATTACK_KERN_COMBI; break; case ATTACK_MODE_ASSOCIATION: user_options_extra->attack_kern = ATTACK_KERN_STRAIGHT; break; } // rules user_options_extra->rule_len_l = (int) strlen (user_options->rule_buf_l); user_options_extra->rule_len_r = (int) strlen (user_options->rule_buf_r); // hc_hash and hc_work* user_options_extra->hc_hash = NULL; user_options_extra->hc_workv = NULL; user_options_extra->hc_workc = 0; if (user_options->benchmark == true) { } else if (user_options->hash_info == true) { } else if (user_options->backend_info == true) { } else if (user_options->keyspace == true) { user_options_extra->hc_workc = user_options->hc_argc; user_options_extra->hc_workv = user_options->hc_argv; } else if (user_options->stdout_flag == true) { user_options_extra->hc_workc = user_options->hc_argc; user_options_extra->hc_workv = user_options->hc_argv; } else { user_options_extra->hc_hash = user_options->hc_argv[0]; user_options_extra->hc_workc = user_options->hc_argc - 1; user_options_extra->hc_workv = user_options->hc_argv + 1; } // wordlist_mode user_options_extra->wordlist_mode = WL_MODE_NONE; if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) { user_options_extra->wordlist_mode = (user_options_extra->hc_workc >= 1) ? WL_MODE_FILE : WL_MODE_STDIN; } else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) { user_options_extra->wordlist_mode = WL_MODE_FILE; } else if (user_options_extra->attack_kern == ATTACK_KERN_BF) { user_options_extra->wordlist_mode = WL_MODE_MASK; } } void user_options_extra_destroy (hashcat_ctx_t *hashcat_ctx) { user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; memset (user_options_extra, 0, sizeof (user_options_extra_t)); } u64 user_options_extra_amplifier (hashcat_ctx_t *hashcat_ctx) { const combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; const mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; const user_options_t *user_options = hashcat_ctx->user_options; const user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; if (user_options->slow_candidates == true) { return 1; } if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) { if (straight_ctx->kernel_rules_cnt) { return straight_ctx->kernel_rules_cnt; } } else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) { if (combinator_ctx->combs_cnt) { return combinator_ctx->combs_cnt; } } else if (user_options_extra->attack_kern == ATTACK_KERN_BF) { if (mask_ctx->bfs_cnt) { return mask_ctx->bfs_cnt; } } return 1; } int user_options_check_files (hashcat_ctx_t *hashcat_ctx) { dictstat_ctx_t *dictstat_ctx = hashcat_ctx->dictstat_ctx; folder_config_t *folder_config = hashcat_ctx->folder_config; logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_ctx; outcheck_ctx_t *outcheck_ctx = hashcat_ctx->outcheck_ctx; outfile_ctx_t *outfile_ctx = hashcat_ctx->outfile_ctx; pidfile_ctx_t *pidfile_ctx = hashcat_ctx->pidfile_ctx; potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; user_options_t *user_options = hashcat_ctx->user_options; // brain #ifdef WITH_BRAIN if (user_options->brain_host) { struct addrinfo hints; memset (&hints, 0, sizeof (hints)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; struct addrinfo *address_info = NULL; const int rc_getaddrinfo = getaddrinfo (user_options->brain_host, NULL, &hints, &address_info); if (rc_getaddrinfo != 0) { fprintf (stderr, "%s: %s\n", user_options->brain_host, gai_strerror (rc_getaddrinfo)); return -1; } freeaddrinfo (address_info); } #endif // common folders #if defined (_WIN) if (hc_path_read (".") == false) { event_log_error (hashcat_ctx, "%s: %s", ".", strerror (errno)); return -1; } #else if (hc_path_read (folder_config->cwd) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->cwd, strerror (errno)); return -1; } #endif if (hc_path_read (folder_config->install_dir) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->install_dir, strerror (errno)); return -1; } if (hc_path_read (folder_config->profile_dir) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->profile_dir, strerror (errno)); return -1; } if (hc_path_write (folder_config->session_dir) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->session_dir, strerror (errno)); return -1; } if (hc_path_read (folder_config->shared_dir) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->shared_dir, strerror (errno)); return -1; } if (hc_path_read (folder_config->cpath_real) == false) { event_log_error (hashcat_ctx, "%s: %s", folder_config->cpath_real, strerror (errno)); return -1; } // hashfile - can be NULL if (user_options_extra->hc_hash != NULL) { if (hc_path_exist (user_options_extra->hc_hash) == true) { if (hc_path_is_directory (user_options_extra->hc_hash) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a hashfile argument.", user_options_extra->hc_hash); return -1; } if (hc_path_read (user_options_extra->hc_hash) == false) { event_log_error (hashcat_ctx, "%s: %s", user_options_extra->hc_hash, strerror (errno)); return -1; } if (hc_path_has_bom (user_options_extra->hc_hash) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", user_options_extra->hc_hash); return -1; } } } // arguments - checks must depend on attack_mode if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { for (int i = 0; i < user_options_extra->hc_workc; i++) { char *wlfile = user_options_extra->hc_workv[i]; if (hc_path_exist (wlfile) == false) { event_log_error (hashcat_ctx, "%s: %s", wlfile, strerror (errno)); return -1; } } for (int i = 0; i < (int) user_options->rp_files_cnt; i++) { char *rp_file = user_options->rp_files[i]; if (hc_path_exist (rp_file) == false) { event_log_error (hashcat_ctx, "%s: %s", rp_file, strerror (errno)); return -1; } if (hc_path_is_directory (rp_file) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a rulefile argument.", rp_file); return -1; } if (hc_path_read (rp_file) == false) { event_log_error (hashcat_ctx, "%s: %s", rp_file, strerror (errno)); return -1; } if (hc_path_has_bom (rp_file) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", rp_file); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { // mode easy mode here because both files must exist and readable if (user_options_extra->hc_workc == 2) { char *dictfile1 = user_options_extra->hc_workv[0]; char *dictfile2 = user_options_extra->hc_workv[1]; if (hc_path_exist (dictfile1) == false) { event_log_error (hashcat_ctx, "%s: %s", dictfile1, strerror (errno)); return -1; } if (hc_path_is_directory (dictfile1) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a wordlist argument.", dictfile1); return -1; } if (hc_path_read (dictfile1) == false) { event_log_error (hashcat_ctx, "%s: %s", dictfile1, strerror (errno)); return -1; } if (hc_path_has_bom (dictfile1) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", dictfile1); return -1; } if (hc_path_exist (dictfile2) == false) { event_log_error (hashcat_ctx, "%s: %s", dictfile2, strerror (errno)); return -1; } if (hc_path_is_directory (dictfile2) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a wordlist argument.", dictfile2); return -1; } if (hc_path_read (dictfile2) == false) { event_log_error (hashcat_ctx, "%s: %s", dictfile2, strerror (errno)); return -1; } if (hc_path_has_bom (dictfile2) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", dictfile2); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_BF) { // if the file exist it's a maskfile and then it must be readable if (user_options_extra->hc_workc == 1) { char *maskfile = user_options_extra->hc_workv[0]; if (hc_path_exist (maskfile) == true) { if (hc_path_is_directory (maskfile) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a maskfile argument.", maskfile); return -1; } if (hc_path_read (maskfile) == false) { event_log_error (hashcat_ctx, "%s: %s", maskfile, strerror (errno)); return -1; } if (hc_path_has_bom (maskfile) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", maskfile); return -1; } } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { if (user_options_extra->hc_workc == 2) { char *wlfile = user_options_extra->hc_workv[0]; char *maskfile = user_options_extra->hc_workv[1]; // for wordlist: can be folder if (hc_path_exist (wlfile) == false) { event_log_error (hashcat_ctx, "%s: %s", wlfile, strerror (errno)); return -1; } // for mask: if the file exist it's a maskfile and then it must be readable if (hc_path_exist (maskfile) == true) { if (hc_path_is_directory (maskfile) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a maskfile argument.", maskfile); return -1; } if (hc_path_read (maskfile) == false) { event_log_error (hashcat_ctx, "%s: %s", maskfile, strerror (errno)); return -1; } if (hc_path_has_bom (maskfile) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", maskfile); return -1; } } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { if (user_options_extra->hc_workc == 2) { char *wlfile = user_options_extra->hc_workv[1]; char *maskfile = user_options_extra->hc_workv[0]; // for wordlist: can be folder if (hc_path_exist (wlfile) == false) { event_log_error (hashcat_ctx, "%s: %s", wlfile, strerror (errno)); return -1; } // for mask: if the file exist it's a maskfile and then it must be readable if (hc_path_exist (maskfile) == true) { if (hc_path_is_directory (maskfile) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a maskfile argument.", maskfile); return -1; } if (hc_path_read (maskfile) == false) { event_log_error (hashcat_ctx, "%s: %s", maskfile, strerror (errno)); return -1; } if (hc_path_has_bom (maskfile) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", maskfile); return -1; } } } } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { for (int i = 0; i < user_options_extra->hc_workc; i++) { char *wlfile = user_options_extra->hc_workv[i]; if (hc_path_exist (wlfile) == false) { event_log_error (hashcat_ctx, "%s: %s", wlfile, strerror (errno)); return -1; } } for (int i = 0; i < (int) user_options->rp_files_cnt; i++) { char *rp_file = user_options->rp_files[i]; if (hc_path_exist (rp_file) == false) { event_log_error (hashcat_ctx, "%s: %s", rp_file, strerror (errno)); return -1; } if (hc_path_is_directory (rp_file) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a rulefile argument.", rp_file); return -1; } if (hc_path_read (rp_file) == false) { event_log_error (hashcat_ctx, "%s: %s", rp_file, strerror (errno)); return -1; } if (hc_path_has_bom (rp_file) == true) { event_log_error (hashcat_ctx, "%s: Byte Order Mark (BOM) was detected", rp_file); return -1; } } } // logfile if (logfile_ctx->enabled == true) { if (hc_path_exist (logfile_ctx->logfile) == true) { if (hc_path_is_directory (logfile_ctx->logfile) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a logfile argument.", logfile_ctx->logfile); return -1; } if (hc_path_write (logfile_ctx->logfile) == false) { event_log_error (hashcat_ctx, "%s: %s", logfile_ctx->logfile, strerror (errno)); return -1; } } else { if (hc_path_create (logfile_ctx->logfile) == false) { event_log_error (hashcat_ctx, "%s: %s", logfile_ctx->logfile, strerror (errno)); return -1; } } } // outfile_check if (outcheck_ctx->enabled == true) { if (hc_path_exist (outcheck_ctx->root_directory) == true) { if (hc_path_is_directory (outcheck_ctx->root_directory) == false) { event_log_error (hashcat_ctx, "Directory specified in outfile-check '%s' is not a directory.", outcheck_ctx->root_directory); return -1; } } } // outfile - can be NULL if (outfile_ctx->filename != NULL) { if (hc_path_exist (outfile_ctx->filename) == true) { if (hc_path_is_directory (outfile_ctx->filename) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as an outfile.", outfile_ctx->filename); return -1; } if (hc_path_write (outfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", outfile_ctx->filename, strerror (errno)); return -1; } } else { if (hc_path_create (outfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", outfile_ctx->filename, strerror (errno)); return -1; } } } // check for outfile vs. hashfile if (hc_same_files (outfile_ctx->filename, user_options_extra->hc_hash) == true) { event_log_error (hashcat_ctx, "Outfile and hashfile cannot point to the same file."); return -1; } // check for outfile vs. cached wordlists if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { for (int i = 0; i < user_options_extra->hc_workc; i++) { char *wlfile = user_options_extra->hc_workv[i]; if (hc_same_files (outfile_ctx->filename, wlfile) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { if (user_options_extra->hc_workc == 2) { char *dictfile1 = user_options_extra->hc_workv[0]; char *dictfile2 = user_options_extra->hc_workv[1]; if (hc_same_files (outfile_ctx->filename, dictfile1) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } if (hc_same_files (outfile_ctx->filename, dictfile2) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { if (user_options_extra->hc_workc == 2) { char *wlfile = user_options_extra->hc_workv[0]; if (hc_same_files (outfile_ctx->filename, wlfile) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { if (user_options_extra->hc_workc == 2) { char *wlfile = user_options_extra->hc_workv[1]; if (hc_same_files (outfile_ctx->filename, wlfile) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_ASSOCIATION) { for (int i = 0; i < user_options_extra->hc_workc; i++) { char *wlfile = user_options_extra->hc_workv[i]; if (hc_same_files (outfile_ctx->filename, wlfile) == true) { event_log_error (hashcat_ctx, "Outfile and wordlist cannot point to the same file."); return -1; } } } // pidfile if (hc_path_exist (pidfile_ctx->filename) == true) { if (hc_path_is_directory (pidfile_ctx->filename) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a pidfile argument.", pidfile_ctx->filename); return -1; } if (hc_path_write (pidfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", pidfile_ctx->filename, strerror (errno)); return -1; } } else { if (hc_path_create (pidfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", pidfile_ctx->filename, strerror (errno)); return -1; } } // potfile if (potfile_ctx->enabled == true) { if (hc_path_exist (potfile_ctx->filename) == true) { if (hc_path_is_directory (potfile_ctx->filename) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a potfile argument.", potfile_ctx->filename); return -1; } if (hc_path_write (potfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", potfile_ctx->filename, strerror (errno)); return -1; } } else { if (hc_path_create (potfile_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", potfile_ctx->filename, strerror (errno)); return -1; } } } // dictstat if (dictstat_ctx->enabled == true) { if (hc_path_exist (dictstat_ctx->filename) == true) { if (hc_path_is_directory (dictstat_ctx->filename) == true) { event_log_error (hashcat_ctx, "%s: A directory cannot be used as a dictstat argument.", dictstat_ctx->filename); return -1; } if (hc_path_write (dictstat_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", dictstat_ctx->filename, strerror (errno)); return -1; } } else { if (hc_path_create (dictstat_ctx->filename) == false) { event_log_error (hashcat_ctx, "%s: %s", dictstat_ctx->filename, strerror (errno)); return -1; } } } // single kernel and module existence check to detect "7z e" errors char *modulefile = (char *) hcmalloc (HCBUFSIZ_TINY); module_filename (folder_config, 0, modulefile, HCBUFSIZ_TINY); if (hc_path_exist (modulefile) == false) { event_log_error (hashcat_ctx, "%s: %s", modulefile, strerror (errno)); event_log_warning (hashcat_ctx, "If you are using the hashcat binary package this error typically indicates a problem during extraction."); event_log_warning (hashcat_ctx, "For example, using \"7z e\" instead of using \"7z x\"."); event_log_warning (hashcat_ctx, NULL); hcfree (modulefile); return -1; } hcfree (modulefile); const bool quiet_save = user_options->quiet; user_options->quiet = true; const int rc = hashconfig_init (hashcat_ctx); user_options->quiet = quiet_save; if (rc == -1) return -1; hashconfig_destroy (hashcat_ctx); // same check but for an backend kernel char *kernelfile = (char *) hcmalloc (HCBUFSIZ_TINY); generate_source_kernel_filename (false, ATTACK_EXEC_OUTSIDE_KERNEL, ATTACK_KERN_STRAIGHT, 400, 0, folder_config->shared_dir, kernelfile); if (hc_path_read (kernelfile) == false) { event_log_error (hashcat_ctx, "%s: %s", kernelfile, strerror (errno)); event_log_warning (hashcat_ctx, "If you are using the hashcat binary package this error typically indicates a problem during extraction."); event_log_warning (hashcat_ctx, "For example, using \"7z e\" instead of using \"7z x\"."); event_log_warning (hashcat_ctx, NULL); hcfree (kernelfile); return -1; } hcfree (kernelfile); // loopback - can't check at this point // tuning file check already done // debugfile check already done // dictstat if (user_options->keyboard_layout_mapping != NULL) { if (hc_path_exist (user_options->keyboard_layout_mapping) == true) { if (hc_path_read (user_options->keyboard_layout_mapping) == false) { event_log_error (hashcat_ctx, "%s: %s", user_options->keyboard_layout_mapping, strerror (errno)); return -1; } } else { event_log_error (hashcat_ctx, "%s: %s", user_options->keyboard_layout_mapping, strerror (errno)); return -1; } } /** * default building options */ /* temporary disabled due to https://github.com/hashcat/hashcat/issues/2379 if (chdir (folder_config->cpath_real) == -1) { event_log_error (hashcat_ctx, "%s: %s", folder_config->cpath_real, strerror (errno)); return -1; } */ // include check // this test needs to be done manually because of macOS opencl runtime // if there's a problem with permission, its not reporting back and erroring out silently const char *files_names[] = { "inc_cipher_aes.cl", "inc_cipher_serpent.cl", "inc_cipher_twofish.cl", "inc_common.cl", "inc_comp_multi_bs.cl", "inc_comp_multi.cl", "inc_comp_single_bs.cl", "inc_comp_single.cl", "inc_rp_optimized.cl", "inc_rp_optimized.h", "inc_simd.cl", "inc_scalar.cl", "inc_types.h", "inc_vendor.h", NULL }; for (int i = 0; files_names[i] != NULL; i++) { char *temp_filename = NULL; hc_asprintf (&temp_filename, "%s/%s", folder_config->cpath_real, files_names[i]); if (hc_path_read (temp_filename) == false) { event_log_error (hashcat_ctx, "%s: %s", temp_filename, strerror (errno)); hcfree (temp_filename); return -1; } hcfree (temp_filename); } // return back to the folder we came from initially (workaround) /* temporary disabled due to https://github.com/hashcat/hashcat/issues/2379 #if defined (_WIN) if (chdir ("..") == -1) { event_log_error (hashcat_ctx, "%s: %s", "..", strerror (errno)); return -1; } #else if (chdir (folder_config->cwd) == -1) { event_log_error (hashcat_ctx, "%s: %s", folder_config->cwd, strerror (errno)); return -1; } #endif */ return 0; } void user_options_logger (hashcat_ctx_t *hashcat_ctx) { user_options_t *user_options = hashcat_ctx->user_options; logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_ctx; logfile_top_char (user_options->separator); #ifdef WITH_BRAIN logfile_top_string (user_options->brain_session_whitelist); #endif logfile_top_string (user_options->cpu_affinity); logfile_top_string (user_options->custom_charset_1); logfile_top_string (user_options->custom_charset_2); logfile_top_string (user_options->custom_charset_3); logfile_top_string (user_options->custom_charset_4); logfile_top_string (user_options->debug_file); logfile_top_string (user_options->encoding_from); logfile_top_string (user_options->encoding_to); logfile_top_string (user_options->induction_dir); logfile_top_string (user_options->keyboard_layout_mapping); logfile_top_string (user_options->markov_hcstat2); logfile_top_string (user_options->backend_devices); logfile_top_string (user_options->opencl_device_types); logfile_top_string (user_options->outfile); logfile_top_string (user_options->outfile_check_dir); logfile_top_string (user_options->potfile_path); logfile_top_string (user_options->restore_file_path); logfile_top_string (user_options->rp_files[0]); logfile_top_string (user_options->rule_buf_l); logfile_top_string (user_options->rule_buf_r); logfile_top_string (user_options->session); logfile_top_string (user_options->truecrypt_keyfiles); logfile_top_string (user_options->veracrypt_keyfiles); #ifdef WITH_BRAIN logfile_top_string (user_options->brain_host); #endif logfile_top_uint64 (user_options->limit); logfile_top_uint64 (user_options->skip); logfile_top_uint (user_options->attack_mode); logfile_top_uint (user_options->benchmark); logfile_top_uint (user_options->benchmark_all); logfile_top_uint (user_options->bitmap_max); logfile_top_uint (user_options->bitmap_min); logfile_top_uint (user_options->debug_mode); logfile_top_uint (user_options->hash_info); logfile_top_uint (user_options->force); logfile_top_uint (user_options->hwmon_disable); logfile_top_uint (user_options->hwmon_temp_abort); logfile_top_uint (user_options->hash_mode); logfile_top_uint (user_options->hex_charset); logfile_top_uint (user_options->hex_salt); logfile_top_uint (user_options->hex_wordlist); logfile_top_uint (user_options->hook_threads); logfile_top_uint (user_options->increment); logfile_top_uint (user_options->increment_max); logfile_top_uint (user_options->increment_min); logfile_top_uint (user_options->keep_guessing); logfile_top_uint (user_options->kernel_accel); logfile_top_uint (user_options->kernel_loops); logfile_top_uint (user_options->kernel_threads); logfile_top_uint (user_options->keyspace); logfile_top_uint (user_options->left); logfile_top_uint (user_options->logfile_disable); logfile_top_uint (user_options->loopback); logfile_top_uint (user_options->machine_readable); logfile_top_uint (user_options->markov_classic); logfile_top_uint (user_options->markov_disable); logfile_top_uint (user_options->markov_threshold); logfile_top_uint (user_options->backend_info); logfile_top_uint (user_options->backend_vector_width); logfile_top_uint (user_options->optimized_kernel_enable); logfile_top_uint (user_options->outfile_autohex); logfile_top_uint (user_options->outfile_check_timer); logfile_top_uint (user_options->outfile_format); logfile_top_uint (user_options->wordlist_autohex_disable); logfile_top_uint (user_options->potfile_disable); logfile_top_uint (user_options->progress_only); logfile_top_uint (user_options->quiet); logfile_top_uint (user_options->remove); logfile_top_uint (user_options->remove_timer); logfile_top_uint (user_options->restore); logfile_top_uint (user_options->restore_disable); logfile_top_uint (user_options->restore_timer); logfile_top_uint (user_options->rp_files_cnt); logfile_top_uint (user_options->rp_gen); logfile_top_uint (user_options->rp_gen_func_max); logfile_top_uint (user_options->rp_gen_func_min); logfile_top_uint (user_options->rp_gen_seed); logfile_top_uint (user_options->runtime); logfile_top_uint (user_options->scrypt_tmto); logfile_top_uint (user_options->segment_size); logfile_top_uint (user_options->self_test_disable); logfile_top_uint (user_options->slow_candidates); logfile_top_uint (user_options->show); logfile_top_uint (user_options->speed_only); logfile_top_uint (user_options->spin_damp); logfile_top_uint (user_options->status); logfile_top_uint (user_options->status_json); logfile_top_uint (user_options->status_timer); logfile_top_uint (user_options->stdout_flag); logfile_top_uint (user_options->usage); logfile_top_uint (user_options->username); logfile_top_uint (user_options->veracrypt_pim_start); logfile_top_uint (user_options->veracrypt_pim_stop); logfile_top_uint (user_options->version); logfile_top_uint (user_options->workload_profile); #ifdef WITH_BRAIN logfile_top_uint (user_options->brain_client); logfile_top_uint (user_options->brain_client_features); logfile_top_uint (user_options->brain_server); logfile_top_uint (user_options->brain_server_timer); logfile_top_uint (user_options->brain_port); logfile_top_uint (user_options->brain_session); #endif }