diff --git a/include/types.h b/include/types.h index ae6bb3037..4c9d58be3 100644 --- a/include/types.h +++ b/include/types.h @@ -1235,6 +1235,7 @@ typedef struct time_t runtime_start; time_t runtime_stop; + time_t prepare_start; time_t prepare_time; time_t proc_start; diff --git a/src/hashcat.c b/src/hashcat.c index 4ba723a30..dba63b688 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -224,156 +224,14 @@ static void goodbye_screen (const user_options_t *user_options, const time_t *pr log_info_nn ("Stopped: %s", ctime (proc_stop)); } -static int outer_loop (user_options_t *user_options, user_options_extra_t *user_options_extra, restore_ctx_t *restore_ctx, folder_config_t *folder_config, logfile_ctx_t *logfile_ctx, tuning_db_t *tuning_db, induct_ctx_t *induct_ctx, outcheck_ctx_t *outcheck_ctx, outfile_ctx_t *outfile_ctx, potfile_ctx_t *potfile_ctx, rules_ctx_t *rules_ctx, dictstat_ctx_t *dictstat_ctx, loopback_ctx_t *loopback_ctx, opencl_ctx_t *opencl_ctx) +static int inner1_loop (user_options_t *user_options, user_options_extra_t *user_options_extra, restore_ctx_t *restore_ctx, logfile_ctx_t *logfile_ctx, induct_ctx_t *induct_ctx, rules_ctx_t *rules_ctx, dictstat_ctx_t *dictstat_ctx, loopback_ctx_t *loopback_ctx, opencl_ctx_t *opencl_ctx, hashconfig_t *hashconfig, hashes_t *hashes, mask_ctx_t *mask_ctx, wl_data_t *wl_data) { - opencl_ctx->devices_status = STATUS_INIT; - //opencl_ctx->run_main_level1 = true; - opencl_ctx->run_main_level2 = true; + //opencl_ctx->run_main_level2 = true; opencl_ctx->run_main_level3 = true; opencl_ctx->run_thread_level1 = true; opencl_ctx->run_thread_level2 = true; - /* - * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass' - * the following algos are skipped entirely - * still needed? there's no more bypass in benchmark mode - * also there's no signs of special benchmark handling in the branch - */ - - /* - if (algorithm_pos > 0) - { - local_free (rd); - - rd = init_restore (argc, argv, user_options); - - data.rd = rd; - } - */ - - int myargc = restore_ctx->argc; - char **myargv = restore_ctx->argv; - - /** - * setup prepare timer - */ - - time_t prepare_start; - - time (&prepare_start); - - /** - * setup variables and buffers depending on hash_mode - */ - - hashconfig_t *hashconfig = (hashconfig_t *) mymalloc (sizeof (hashconfig_t)); - - data.hashconfig = hashconfig; - - const int rc_hashconfig = hashconfig_init (hashconfig, user_options); - - if (rc_hashconfig == -1) return -1; - - /** - * potfile show/left depends on hash_mode, so it's called here first time - */ - - if (user_options->show == true || user_options->left == true) - { - outfile_write_open (outfile_ctx); - - SUPPRESS_OUTPUT = 1; - - potfile_read_open (potfile_ctx); - - potfile_read_parse (potfile_ctx, hashconfig); - - potfile_read_close (potfile_ctx); - - SUPPRESS_OUTPUT = 0; - } - - /** - * load hashes, stage 1 - */ - - hashes_t *hashes = (hashes_t *) mymalloc (sizeof (hashes_t)); - - data.hashes = hashes; - - const int rc_hashes_init_stage1 = hashes_init_stage1 (hashes, hashconfig, potfile_ctx, outfile_ctx, user_options, myargv[user_options_extra->optind]); - - if (rc_hashes_init_stage1 == -1) return -1; - - if ((user_options->keyspace == false) && (user_options->stdout_flag == false) && (user_options->opencl_info == false)) - { - if (hashes->hashes_cnt == 0) - { - log_error ("ERROR: No hashes loaded"); - - return -1; - } - } - - /** - * potfile show/left final - */ - - if (user_options->show == true || user_options->left == true) - { - outfile_write_close (outfile_ctx); - - potfile_hash_free (potfile_ctx, hashconfig); - - //if (user_options->quiet == false) log_info_nn (""); - - return 0; - } - - /** - * Potfile removes - */ - - int potfile_remove_cracks = 0; - - if (user_options->potfile_disable == 0) - { - if (user_options->quiet == false) log_info_nn ("Comparing hashes with potfile entries..."); - - potfile_remove_cracks = potfile_remove_parse (potfile_ctx, hashconfig, hashes); - } - - /** - * load hashes, stage 2, remove duplicates, build base structure - */ - - const u32 hashes_cnt_orig = hashes->hashes_cnt; - - const int rc_hashes_init_stage2 = hashes_init_stage2 (hashes, hashconfig, opencl_ctx, user_options); - - if (rc_hashes_init_stage2 == -1) return -1; - - /** - * load hashes, stage 3, automatic Optimizers - */ - - const int rc_hashes_init_stage3 = hashes_init_stage3 (hashes, hashconfig, user_options); - - if (rc_hashes_init_stage3 == -1) return -1; - - hashes_logger (hashes, logfile_ctx); - - /** - * bitmaps - */ - - bitmap_ctx_t *bitmap_ctx = (bitmap_ctx_t *) mymalloc (sizeof (bitmap_ctx_t)); - - data.bitmap_ctx = bitmap_ctx; - - bitmap_ctx_init (bitmap_ctx, user_options, hashconfig, hashes); - /** * word len */ @@ -416,611 +274,412 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ } /** - * charsets : keep them together for more easy maintainnce + * Init mask stuff */ - mask_ctx_t *mask_ctx = (mask_ctx_t *) mymalloc (sizeof (mask_ctx_t)); + if (user_options->attack_mode == ATTACK_MODE_HYBRID1 || user_options->attack_mode == ATTACK_MODE_HYBRID2 || user_options->attack_mode == ATTACK_MODE_BF) + { + mask_ctx->mask = mask_ctx->masks[mask_ctx->masks_pos]; - data.mask_ctx = mask_ctx; + if (mask_ctx->mask_from_file == true) + { + if (mask_ctx->mask[0] == '\\' && mask_ctx->mask[1] == '#') mask_ctx->mask++; // escaped comment sign (sharp) "\#" - const int rc_mask_init = mask_ctx_init (mask_ctx, user_options, user_options_extra, folder_config, restore_ctx, hashconfig); + char *str_ptr; + uint str_pos; - if (rc_mask_init == -1) return -1; + uint mask_offset = 0; - /** - * HM devices: init - */ + uint separator_cnt; - hm_attrs_t hm_adapters_adl[DEVICES_MAX]; - hm_attrs_t hm_adapters_nvapi[DEVICES_MAX]; - hm_attrs_t hm_adapters_nvml[DEVICES_MAX]; - hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX]; + for (separator_cnt = 0; separator_cnt < 4; separator_cnt++) + { + str_ptr = strstr (mask_ctx->mask + mask_offset, ","); - memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl)); - memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi)); - memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml)); - memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl)); + if (str_ptr == NULL) break; - if (user_options->gpu_temp_disable == false) - { - ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR)); - NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR)); - NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR)); - XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR)); + str_pos = str_ptr - mask_ctx->mask; - data.hm_adl = NULL; - data.hm_nvapi = NULL; - data.hm_nvml = NULL; - data.hm_xnvctrl = NULL; + // escaped separator, i.e. "\," - if ((opencl_ctx->need_nvml == true) && (nvml_init (nvml) == 0)) - { - data.hm_nvml = nvml; - } + if (str_pos > 0) + { + if (mask_ctx->mask[str_pos - 1] == '\\') + { + separator_cnt --; - if (data.hm_nvml) - { - if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS) - { - HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 }; + mask_offset = str_pos + 1; - int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle); + continue; + } + } - int tmp_out = 0; + // reset the offset - for (int i = 0; i < tmp_in; i++) - { - hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i]; - } + mask_offset = 0; - for (int i = 0; i < tmp_out; i++) + mask_ctx->mask[str_pos] = 0; + + switch (separator_cnt) { - unsigned int speed; + case 0: + mp_reset_usr (mask_ctx->mp_usr, 0); - if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1; + user_options->custom_charset_1 = mask_ctx->mask; - // doesn't seem to create any advantages - //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS); - //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON); - } - } - } + mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_1, 0, hashconfig, user_options); + break; - if ((opencl_ctx->need_nvapi == true) && (nvapi_init (nvapi) == 0)) - { - data.hm_nvapi = nvapi; - } + case 1: + mp_reset_usr (mask_ctx->mp_usr, 1); - if (data.hm_nvapi) - { - if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK) - { - HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 }; + user_options->custom_charset_2 = mask_ctx->mask; - int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle); + mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_2, 1, hashconfig, user_options); + break; - int tmp_out = 0; + case 2: + mp_reset_usr (mask_ctx->mp_usr, 2); - for (int i = 0; i < tmp_in; i++) - { - hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i]; + user_options->custom_charset_3 = mask_ctx->mask; + + mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_3, 2, hashconfig, user_options); + break; + + case 3: + mp_reset_usr (mask_ctx->mp_usr, 3); + + user_options->custom_charset_4 = mask_ctx->mask; + + mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_4, 3, hashconfig, user_options); + break; } + + mask_ctx->mask += str_pos + 1; } - } - if ((opencl_ctx->need_xnvctrl == true) && (xnvctrl_init (xnvctrl) == 0)) - { - data.hm_xnvctrl = xnvctrl; - } + /** + * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\") + * it would be interpreted as a custom charset definition. + * + * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",") + * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by "," + */ - if (data.hm_xnvctrl) - { - if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0) - { - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + uint mask_len_cur = strlen (mask_ctx->mask); - if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + uint mask_out_pos = 0; + char mask_prev = 0; - hm_adapters_xnvctrl[device_id].xnvctrl = device_id; + for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++) + { + if (mask_ctx->mask[mask_iter] == ',') + { + if (mask_prev == '\\') + { + mask_out_pos -= 1; // this means: skip the previous "\" + } + } - int speed = 0; + mask_prev = mask_ctx->mask[mask_iter]; - if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1; - } + mask_ctx->mask[mask_out_pos] = mask_ctx->mask[mask_iter]; } - } - if ((opencl_ctx->need_adl == true) && (adl_init (adl) == 0)) - { - data.hm_adl = adl; + mask_ctx->mask[mask_out_pos] = 0; } - if (data.hm_adl) + if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2)) { - if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK) - { - // total number of adapters - - int hm_adapters_num; + mask_ctx->css_buf = mp_gen_css (mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt, hashconfig, user_options); - if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1; + uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } }; - // adapter info + mp_css_to_uniq_tbl (mask_ctx->css_cnt, mask_ctx->css_buf, uniq_tbls); - LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num); + sp_tbl_to_css (mask_ctx->root_table_buf, mask_ctx->markov_table_buf, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, user_options->markov_threshold, uniq_tbls); - if (lpAdapterInfo == NULL) return -1; + data.combs_cnt = sp_get_sum (0, mask_ctx->css_cnt, mask_ctx->root_css_buf); - // get a list (of ids of) valid/usable adapters + // args - int num_adl_adapters = 0; + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo); + if (device_param->skipped) continue; - if (num_adl_adapters > 0) + device_param->kernel_params_mp[0] = &device_param->d_combs; + device_param->kernel_params_mp[1] = &device_param->d_root_css_buf; + device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf; + + device_param->kernel_params_mp_buf64[3] = 0; + device_param->kernel_params_mp_buf32[4] = mask_ctx->css_cnt; + device_param->kernel_params_mp_buf32[5] = 0; + device_param->kernel_params_mp_buf32[6] = 0; + device_param->kernel_params_mp_buf32[7] = 0; + + if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { - hc_thread_mutex_lock (mux_hwmon); + if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1; + } + else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) + { + device_param->kernel_params_mp_buf32[5] = 0; + device_param->kernel_params_mp_buf32[6] = 0; + device_param->kernel_params_mp_buf32[7] = 0; + } - // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all); + cl_int CL_err = CL_SUCCESS; - hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]); + for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]); + for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]); - hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); - hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + if (CL_err != CL_SUCCESS) + { + log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err)); - hc_thread_mutex_unlock (mux_hwmon); + return -1; } - myfree (valid_adl_device_list); - myfree (lpAdapterInfo); + CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, mask_ctx->root_css_buf, 0, NULL, NULL); + CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, mask_ctx->markov_css_buf, 0, NULL, NULL); + + if (CL_err != CL_SUCCESS) + { + log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err)); + + return -1; + } } } - - if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) + else if (user_options->attack_mode == ATTACK_MODE_BF) { - user_options->gpu_temp_disable = true; - } - } + mask_ctx->css_buf = mp_gen_css (mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt, hashconfig, user_options); - /** - * OpenCL devices: allocate buffer for device specific information - */ + if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) + { + u32 css_cnt_unicode = mask_ctx->css_cnt * 2; - ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (opencl_ctx->devices_cnt, sizeof (ADLOD6MemClockState)); + cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t)); - int *od_power_control_status = (int *) mycalloc (opencl_ctx->devices_cnt, sizeof (int)); + for (uint i = 0, j = 0; i < mask_ctx->css_cnt; i += 1, j += 2) + { + memcpy (&css_buf_unicode[j + 0], &mask_ctx->css_buf[i], sizeof (cs_t)); - unsigned int *nvml_power_limit = (unsigned int *) mycalloc (opencl_ctx->devices_cnt, sizeof (unsigned int)); + css_buf_unicode[j + 1].cs_buf[0] = 0; + css_buf_unicode[j + 1].cs_len = 1; + } - /** - * User-defined GPU temp handling - */ + myfree (mask_ctx->css_buf); - if (user_options->gpu_temp_disable == true) - { - user_options->gpu_temp_abort = 0; - user_options->gpu_temp_retain = 0; - } + mask_ctx->css_buf = css_buf_unicode; + mask_ctx->css_cnt = css_cnt_unicode; + } - /** - * enable custom signal handler(s) - */ + // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode) - if (user_options->benchmark == false) - { - hc_signal (sigHandler_default); - } - else - { - hc_signal (sigHandler_benchmark); - } + uint mask_min = pw_min; + uint mask_max = pw_max; - /** - * inform the user - */ + if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) + { + mask_min *= 2; + mask_max *= 2; + } - if (user_options->quiet == false) - { - log_info ("Hashes: %u digests; %u unique digests, %u unique salts", hashes_cnt_orig, hashes->digests_cnt, hashes->salts_cnt); + if ((mask_ctx->css_cnt < mask_min) || (mask_ctx->css_cnt > mask_max)) + { + if (mask_ctx->css_cnt < mask_min) + { + log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask_ctx->mask); + } - log_info ("Bitmaps: %u bits, %u entries, 0x%08x mask, %u bytes, %u/%u rotates", bitmap_ctx->bitmap_bits, bitmap_ctx->bitmap_nums, bitmap_ctx->bitmap_mask, bitmap_ctx->bitmap_size, bitmap_ctx->bitmap_shift1, bitmap_ctx->bitmap_shift2); + if (mask_ctx->css_cnt > mask_max) + { + log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask_ctx->mask); + } - if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) - { - log_info ("Rules: %u", rules_ctx->kernel_rules_cnt); - } + // skip to next mask - if (user_options->quiet == false) log_info (""); + logfile_sub_msg ("STOP"); - if (hashconfig->opti_type) - { - log_info ("Applicable Optimizers:"); + return 0; + } - for (uint i = 0; i < 32; i++) + u32 css_cnt_orig = mask_ctx->css_cnt; + + if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH) { - const uint opti_bit = 1u << i; + if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT) + { + uint salt_len = (uint) hashes->salts_buf[0].salt_len; + char *salt_buf = (char *) hashes->salts_buf[0].salt_buf; - if (hashconfig->opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit)); - } - } + uint css_cnt_salt = mask_ctx->css_cnt + salt_len; - if (user_options->quiet == false) log_info (""); + cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t)); - /** - * Watchdog and Temperature balance - */ + memcpy (css_buf_salt, mask_ctx->css_buf, mask_ctx->css_cnt * sizeof (cs_t)); - if (user_options->gpu_temp_disable == false && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) - { - log_info ("Watchdog: Hardware Monitoring Interface not found on your system"); - } + for (uint i = 0, j = mask_ctx->css_cnt; i < salt_len; i++, j++) + { + css_buf_salt[j].cs_buf[0] = salt_buf[i]; + css_buf_salt[j].cs_len = 1; + } - if (user_options->gpu_temp_abort == 0) - { - log_info ("Watchdog: Temperature abort trigger disabled"); - } - else - { - log_info ("Watchdog: Temperature abort trigger set to %uc", user_options->gpu_temp_abort); - } + myfree (mask_ctx->css_buf); - if (user_options->gpu_temp_retain == 0) - { - log_info ("Watchdog: Temperature retain trigger disabled"); - } - else - { - log_info ("Watchdog: Temperature retain trigger set to %uc", user_options->gpu_temp_retain); - } + mask_ctx->css_buf = css_buf_salt; + mask_ctx->css_cnt = css_cnt_salt; + } + } - if (user_options->quiet == false) log_info (""); - } + uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } }; - /** - * HM devices: copy - */ + mp_css_to_uniq_tbl (mask_ctx->css_cnt, mask_ctx->css_buf, uniq_tbls); - if (user_options->gpu_temp_disable == false) - { - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + sp_tbl_to_css (mask_ctx->root_table_buf, mask_ctx->markov_table_buf, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, user_options->markov_threshold, uniq_tbls); - if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + data.words_cnt = sp_get_sum (0, mask_ctx->css_cnt, mask_ctx->root_css_buf); - if (device_param->skipped) continue; + // copy + args - const uint platform_devices_id = device_param->platform_devices_id; + uint css_cnt_l = mask_ctx->css_cnt; + uint css_cnt_r; - if (device_param->device_vendor_id == VENDOR_ID_AMD) + if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { - data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl; - data.hm_device[device_id].nvapi = 0; - data.hm_device[device_id].nvml = 0; - data.hm_device[device_id].xnvctrl = 0; - data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version; - data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported; - data.hm_device[device_id].fan_set_supported = 0; + if (css_cnt_orig < 6) + { + css_cnt_r = 1; + } + else if (css_cnt_orig == 6) + { + css_cnt_r = 2; + } + else + { + if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) + { + if (css_cnt_orig == 8 || css_cnt_orig == 10) + { + css_cnt_r = 2; + } + else + { + css_cnt_r = 4; + } + } + else + { + if ((mask_ctx->css_buf[0].cs_len * mask_ctx->css_buf[1].cs_len * mask_ctx->css_buf[2].cs_len) > 256) + { + css_cnt_r = 3; + } + else + { + css_cnt_r = 4; + } + } + } } - - if (device_param->device_vendor_id == VENDOR_ID_NV) + else { - data.hm_device[device_id].adl = 0; - data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi; - data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml; - data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl; - data.hm_device[device_id].od_version = 0; - data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported; - data.hm_device[device_id].fan_set_supported = 0; - } - } - } + css_cnt_r = 1; - /** - * powertune on user request - */ + /* unfinished code? + int sum = css_buf[css_cnt_r - 1].cs_len; - if (user_options->powertune_enable == true) - { - hc_thread_mutex_lock (mux_hwmon); + for (uint i = 1; i < 4 && i < css_cnt; i++) + { + if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + css_cnt_r++; - if (device_param->skipped) continue; + sum *= css_buf[css_cnt_r - 1].cs_len; + } + */ + } - if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_AMD) - { - /** - * Temporary fix: - * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff - * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately - * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem) - * Driver / ADL bug? - */ + css_cnt_l -= css_cnt_r; - if (data.hm_device[device_id].od_version == 6) - { - int ADL_rc; + mask_ctx->bfs_cnt = sp_get_sum (0, css_cnt_r, mask_ctx->root_css_buf); - // check powertune capabilities first, if not available then skip device + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - int powertune_supported = 0; + if (device_param->skipped) continue; - if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK) - { - log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); + device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf; + device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf; + device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf; - return -1; - } + device_param->kernel_params_mp_l_buf64[3] = 0; + device_param->kernel_params_mp_l_buf32[4] = css_cnt_l; + device_param->kernel_params_mp_l_buf32[5] = css_cnt_r; + device_param->kernel_params_mp_l_buf32[6] = 0; + device_param->kernel_params_mp_l_buf32[7] = 0; + device_param->kernel_params_mp_l_buf32[8] = 0; - // first backup current value, we will restore it later + if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1; + if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1; - if (powertune_supported != 0) - { - // powercontrol settings + device_param->kernel_params_mp_r[0] = &device_param->d_bfs; + device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf; + device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf; - ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + device_param->kernel_params_mp_r_buf64[3] = 0; + device_param->kernel_params_mp_r_buf32[4] = css_cnt_r; + device_param->kernel_params_mp_r_buf32[5] = 0; + device_param->kernel_params_mp_r_buf32[6] = 0; + device_param->kernel_params_mp_r_buf32[7] = 0; - if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK) - { - ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]); - } + cl_int CL_err = CL_SUCCESS; - if (ADL_rc != ADL_OK) - { - log_error ("ERROR: Failed to get current ADL PowerControl settings"); + for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]); + for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]); + for (uint i = 4; i < 9; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]); - return -1; - } + for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]); + for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]); + for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]); - if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) - { - log_error ("ERROR: Failed to set new ADL PowerControl values"); + if (CL_err != CL_SUCCESS) + { + log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err)); - return -1; - } + return -1; + } - // clocks + CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, mask_ctx->root_css_buf, 0, NULL, NULL); + CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, mask_ctx->markov_css_buf, 0, NULL, NULL); - memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState)); + if (CL_err != CL_SUCCESS) + { + log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err)); - od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2; + return -1; + } + } + } + } - if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK) - { - log_error ("ERROR: Failed to get ADL memory and engine clock frequency"); + /** + * update induction directory scan + */ - return -1; - } - - // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings - - ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0}; - - if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK) - { - log_error ("ERROR: Failed to get ADL device capabilities"); - - return -1; - } - - int engine_clock_max = (int) (0.6666 * caps.sEngineClockRange.iMax); - int memory_clock_max = (int) (0.6250 * caps.sMemoryClockRange.iMax); - - int warning_trigger_engine = (int) (0.25 * engine_clock_max); - int warning_trigger_memory = (int) (0.25 * memory_clock_max); - - int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; - int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; - - // warning if profile has too low max values - - if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine) - { - log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance"); - } - - if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory) - { - log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance"); - } - - ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); - - performance_state->iNumberOfPerformanceLevels = 2; - - performance_state->aLevels[0].iEngineClock = engine_clock_profile_max; - performance_state->aLevels[1].iEngineClock = engine_clock_profile_max; - performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max; - performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max; - - if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) - { - log_info ("ERROR: Failed to set ADL performance state"); - - return -1; - } - - local_free (performance_state); - } - - // set powertune value only - - if (powertune_supported != 0) - { - // powertune set - ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; - - if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK) - { - log_error ("ERROR: Failed to get current ADL PowerControl settings"); - - return -1; - } - - if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) - { - log_error ("ERROR: Failed to set new ADL PowerControl values"); - - return -1; - } - } - } - } - - if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_NV) - { - // first backup current value, we will restore it later - - unsigned int limit; - - bool powertune_supported = false; - - if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS) - { - powertune_supported = true; - } - - // if backup worked, activate the maximum allowed - - if (powertune_supported == true) - { - unsigned int minLimit; - unsigned int maxLimit; - - if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS) - { - if (maxLimit > 0) - { - if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS) - { - // now we can be sure we need to reset later - - nvml_power_limit[device_id] = limit; - } - } - } - } - } - } - - hc_thread_mutex_unlock (mux_hwmon); - } - - #if defined (DEBUG) - if (user_options->benchmark == true) log_info ("Hashmode: %d", hashconfig->hash_mode); - #endif - - if (user_options->quiet == false) log_info_nn ("Initializing device kernels and memory..."); - - /* - session_ctx_t *session_ctx = (session_ctx_t *) mymalloc (sizeof (session_ctx_t)); - - data.session_ctx = session_ctx; - - session_ctx_init (session_ctx); - */ - - opencl_session_begin (opencl_ctx, hashconfig, hashes, rules_ctx, user_options, user_options_extra, folder_config, bitmap_ctx, tuning_db); - - if (user_options->quiet == false) log_info_nn (""); - - /** - * Store initial fanspeed if gpu_temp_retain is enabled - */ - - if (user_options->gpu_temp_disable == false) - { - if (user_options->gpu_temp_retain) - { - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - - if (device_param->skipped) continue; - - hc_thread_mutex_lock (mux_hwmon); - - if (data.hm_device[device_id].fan_get_supported == true) - { - const int fanspeed = hm_get_fanspeed_with_device_id (opencl_ctx, device_id); - const int fanpolicy = hm_get_fanpolicy_with_device_id (opencl_ctx, device_id); - - // we also set it to tell the OS we take control over the fan and it's automatic controller - // if it was set to automatic. we do not control user-defined fanspeeds. - - if (fanpolicy == 1) - { - data.hm_device[device_id].fan_set_supported = true; - - int rc = -1; - - if (device_param->device_vendor_id == VENDOR_ID_AMD) - { - rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1); - } - else if (device_param->device_vendor_id == VENDOR_ID_NV) - { - #if defined (__linux__) - rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE); - #endif - - #if defined (_WIN) - rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1); - #endif - } - - if (rc == 0) - { - data.hm_device[device_id].fan_set_supported = 1; - } - else - { - log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1); - - data.hm_device[device_id].fan_set_supported = 0; - } - } - else - { - data.hm_device[device_id].fan_set_supported = 0; - } - } - - hc_thread_mutex_unlock (mux_hwmon); - } - } - } - - /** - * In benchmark-mode, inform user which algorithm is checked - */ - - if (user_options->benchmark == true) - { - if (user_options->machine_readable == false) - { - char *hash_type = strhashtype (hashconfig->hash_mode); // not a bug - - log_info ("Hashtype: %s", hash_type); - log_info (""); - } - } - - /** - * keep track of the progress - */ - - data.words_progress_done = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); - data.words_progress_rejected = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); - data.words_progress_restored = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); + induct_ctx_scan (induct_ctx); /** - * dictstat + * dictstat read */ dictstat_read (dictstat_ctx); @@ -1029,10 +688,6 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ * dictionary pad */ - wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t)); - - wl_data_init (wl_data, user_options, hashconfig); - uint dictcnt = 0; char **dictfiles = NULL; @@ -1040,11 +695,11 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ { if (user_options_extra->wordlist_mode == WL_MODE_FILE) { - int wls_left = myargc - (user_options_extra->optind + 1); + int wls_left = restore_ctx->argc - (user_options_extra->optind + 1); for (int i = 0; i < wls_left; i++) { - char *l0_filename = myargv[user_options_extra->optind + 1 + i]; + char *l0_filename = restore_ctx->argv[user_options_extra->optind + 1 + i]; struct stat l0_stat; @@ -1128,8 +783,8 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ { // display - char *dictfile1 = myargv[user_options_extra->optind + 1 + 0]; - char *dictfile2 = myargv[user_options_extra->optind + 1 + 1]; + char *dictfile1 = restore_ctx->argv[user_options_extra->optind + 1 + 0]; + char *dictfile2 = restore_ctx->argv[user_options_extra->optind + 1 + 1]; // find the bigger dictionary and use as base @@ -1286,11 +941,11 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ // base - int wls_left = myargc - (user_options_extra->optind + 2); + int wls_left = restore_ctx->argc - (user_options_extra->optind + 2); for (int i = 0; i < wls_left; i++) { - char *filename = myargv[user_options_extra->optind + 1 + i]; + char *filename = restore_ctx->argv[user_options_extra->optind + 1 + i]; struct stat file_stat; @@ -1373,11 +1028,11 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ // base - int wls_left = myargc - (user_options_extra->optind + 2); + int wls_left = restore_ctx->argc - (user_options_extra->optind + 2); for (int i = 0; i < wls_left; i++) { - char *filename = myargv[user_options_extra->optind + 2 + i]; + char *filename = restore_ctx->argv[user_options_extra->optind + 2 + i]; struct stat file_stat; @@ -1457,1066 +1112,1445 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ data.pw_max = pw_max; /** - * weak hash check is the first to write to potfile, so open it for writing from here - */ - - potfile_write_open (potfile_ctx); - - /** - * weak hash check + * prevent the user from using --skip/--limit together w/ maskfile and or dictfile */ - if (user_options->weak_hash_threshold >= hashes->salts_cnt) + if (user_options->skip != 0 || user_options->limit != 0) { - hc_device_param_t *device_param = NULL; - - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + if ((mask_ctx->masks_cnt > 1) || (dictcnt > 1)) { - device_param = &opencl_ctx->devices_param[device_id]; - - if (device_param->skipped) continue; + log_error ("ERROR: --skip/--limit are not supported with --increment or mask files"); - break; + return -1; } + } - if (user_options->quiet == false) log_info_nn ("Checking for weak hashes..."); + /** + * prevent the user from using --keyspace together w/ maskfile and or dictfile + */ - for (uint salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++) + if (user_options->keyspace == true) + { + if ((mask_ctx->masks_cnt > 1) || (dictcnt > 1)) { - weak_hash_check (opencl_ctx, device_param, user_options, user_options_extra, rules_ctx, hashconfig, hashes, salt_pos); + log_error ("ERROR: --keyspace is not supported with --increment or mask files"); + + return -1; } } /** - * status and monitor threads + * keep track of the progress */ - uint inner_threads_cnt = 0; - - hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); - - data.shutdown_inner = 0; + data.words_progress_done = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); + data.words_progress_rejected = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); + data.words_progress_restored = (u64 *) mycalloc (hashes->salts_cnt, sizeof (u64)); /** - * Outfile remove - */ + * main inner loop + */ - if (user_options->keyspace == false && user_options->benchmark == false && user_options->stdout_flag == false) + restore_data_t *rd = restore_ctx->rd; + + for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++) { - hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL); + if (opencl_ctx->run_main_level3 == false) break; - inner_threads_cnt++; + //opencl_ctx->run_main_level1 = true; + //opencl_ctx->run_main_level2 = true; + //opencl_ctx->run_main_level3 = true; + opencl_ctx->run_thread_level1 = true; + opencl_ctx->run_thread_level2 = true; - if (outcheck_ctx->enabled == true) - { - hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL); + rd->dictpos = dictpos; - inner_threads_cnt++; - } - } + logfile_generate_subid (logfile_ctx); - /** - * main loop - */ + logfile_sub_msg ("START"); - if (user_options->quiet == false) - { - if (potfile_remove_cracks > 0) - { - if (potfile_remove_cracks == 1) - { - log_info ("INFO: Removed 1 hash found in potfile"); - log_info (""); - } - else - { - log_info ("INFO: Removed %d hashes found in potfile", potfile_remove_cracks); - log_info (""); - } - } - } + memset (data.words_progress_done, 0, hashes->salts_cnt * sizeof (u64)); + memset (data.words_progress_rejected, 0, hashes->salts_cnt * sizeof (u64)); + memset (data.words_progress_restored, 0, hashes->salts_cnt * sizeof (u64)); - // still needed? - // bool initial_restore_done = false; + memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t)); - // still needed? - // mask_ctx->masks_cnt = maskcnt; + data.cpt_pos = 0; - restore_data_t *rd = restore_ctx->rd; + data.cpt_start = time (NULL); - for (uint masks_pos = rd->masks_pos; masks_pos < mask_ctx->masks_cnt; masks_pos++) - { - //opencl_ctx->run_main_level1 = true; - //opencl_ctx->run_main_level2 = true; - opencl_ctx->run_main_level3 = true; - opencl_ctx->run_thread_level1 = true; - opencl_ctx->run_thread_level2 = true; + data.cpt_total = 0; + + data.words_cur = 0; + + if (rd->words_cur) + { + data.words_cur = rd->words_cur; + + user_options->skip = 0; + } - if (masks_pos > rd->masks_pos) + if (user_options->skip) { - rd->dictpos = 0; + data.words_cur = user_options->skip; + + user_options->skip = 0; } - rd->masks_pos = masks_pos; + data.ms_paused = 0; - mask_ctx->masks_pos = masks_pos; + data.kernel_power_final = 0; - if (user_options->attack_mode == ATTACK_MODE_HYBRID1 || user_options->attack_mode == ATTACK_MODE_HYBRID2 || user_options->attack_mode == ATTACK_MODE_BF) + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) { - mask_ctx->mask = mask_ctx->masks[mask_ctx->masks_pos]; + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - if (mask_ctx->mask_from_file == true) - { - if (mask_ctx->mask[0] == '\\' && mask_ctx->mask[1] == '#') mask_ctx->mask++; // escaped comment sign (sharp) "\#" + if (device_param->skipped) continue; - char *str_ptr; - uint str_pos; + device_param->speed_pos = 0; - uint mask_offset = 0; + memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64)); + memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double)); - uint separator_cnt; + device_param->exec_pos = 0; - for (separator_cnt = 0; separator_cnt < 4; separator_cnt++) - { - str_ptr = strstr (mask_ctx->mask + mask_offset, ","); + memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double)); - if (str_ptr == NULL) break; + device_param->outerloop_pos = 0; + device_param->outerloop_left = 0; + device_param->innerloop_pos = 0; + device_param->innerloop_left = 0; - str_pos = str_ptr - mask_ctx->mask; + // some more resets: - // escaped separator, i.e. "\," + if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws); - if (str_pos > 0) - { - if (mask_ctx->mask[str_pos - 1] == '\\') - { - separator_cnt --; + device_param->pws_cnt = 0; - mask_offset = str_pos + 1; + device_param->words_off = 0; + device_param->words_done = 0; + } - continue; - } - } + // figure out some workload - // reset the offset + if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) + { + if (user_options_extra->wordlist_mode == WL_MODE_FILE) + { + char *dictfile = NULL; - mask_offset = 0; + if (induct_ctx->induction_dictionaries_cnt) + { + dictfile = induct_ctx->induction_dictionaries[0]; + } + else + { + dictfile = dictfiles[dictpos]; + } - mask_ctx->mask[str_pos] = 0; + data.dictfile = dictfile; - switch (separator_cnt) - { - case 0: - mp_reset_usr (mask_ctx->mp_usr, 0); + logfile_sub_string (dictfile); - user_options->custom_charset_1 = mask_ctx->mask; + for (uint i = 0; i < user_options->rp_files_cnt; i++) + { + logfile_sub_var_string ("rulefile", user_options->rp_files[i]); + } - mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_1, 0, hashconfig, user_options); - break; + FILE *fd2 = fopen (dictfile, "rb"); - case 1: - mp_reset_usr (mask_ctx->mp_usr, 1); + if (fd2 == NULL) + { + log_error ("ERROR: %s: %s", dictfile, strerror (errno)); - user_options->custom_charset_2 = mask_ctx->mask; + return -1; + } - mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_2, 1, hashconfig, user_options); - break; + data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); - case 2: - mp_reset_usr (mask_ctx->mp_usr, 2); + fclose (fd2); - user_options->custom_charset_3 = mask_ctx->mask; + if (data.words_cnt == 0) + { + logfile_sub_msg ("STOP"); - mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_3, 2, hashconfig, user_options); - break; + continue; + } + } + } + else if (user_options->attack_mode == ATTACK_MODE_COMBI) + { + char *dictfile = data.dictfile; + char *dictfile2 = data.dictfile2; - case 3: - mp_reset_usr (mask_ctx->mp_usr, 3); + logfile_sub_string (dictfile); + logfile_sub_string (dictfile2); - user_options->custom_charset_4 = mask_ctx->mask; + if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT) + { + FILE *fd2 = fopen (dictfile, "rb"); - mp_setup_usr (mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_4, 3, hashconfig, user_options); - break; - } + if (fd2 == NULL) + { + log_error ("ERROR: %s: %s", dictfile, strerror (errno)); - mask_ctx->mask += str_pos + 1; + return -1; } - /** - * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\") - * it would be interpreted as a custom charset definition. - * - * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",") - * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by "," - */ - - uint mask_len_cur = strlen (mask_ctx->mask); + data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); - uint mask_out_pos = 0; - char mask_prev = 0; + fclose (fd2); + } + else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT) + { + FILE *fd2 = fopen (dictfile2, "rb"); - for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++) + if (fd2 == NULL) { - if (mask_ctx->mask[mask_iter] == ',') - { - if (mask_prev == '\\') - { - mask_out_pos -= 1; // this means: skip the previous "\" - } - } - - mask_prev = mask_ctx->mask[mask_iter]; + log_error ("ERROR: %s: %s", dictfile2, strerror (errno)); - mask_ctx->mask[mask_out_pos] = mask_ctx->mask[mask_iter]; + return -1; } - mask_ctx->mask[mask_out_pos] = 0; + data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile2, dictstat_ctx); + + fclose (fd2); + } + + if (data.words_cnt == 0) + { + logfile_sub_msg ("STOP"); + + continue; } + } + else if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2)) + { + char *dictfile = NULL; - if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2)) + if (induct_ctx->induction_dictionaries_cnt) + { + dictfile = induct_ctx->induction_dictionaries[0]; + } + else { - mask_ctx->css_buf = mp_gen_css (mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt, hashconfig, user_options); + dictfile = dictfiles[dictpos]; + } - uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } }; + data.dictfile = dictfile; - mp_css_to_uniq_tbl (mask_ctx->css_cnt, mask_ctx->css_buf, uniq_tbls); + logfile_sub_string (dictfile); + logfile_sub_string (mask_ctx->mask); - sp_tbl_to_css (mask_ctx->root_table_buf, mask_ctx->markov_table_buf, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, user_options->markov_threshold, uniq_tbls); + FILE *fd2 = fopen (dictfile, "rb"); - data.combs_cnt = sp_get_sum (0, mask_ctx->css_cnt, mask_ctx->root_css_buf); + if (fd2 == NULL) + { + log_error ("ERROR: %s: %s", dictfile, strerror (errno)); - // args + return -1; + } - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); - if (device_param->skipped) continue; + fclose (fd2); - device_param->kernel_params_mp[0] = &device_param->d_combs; - device_param->kernel_params_mp[1] = &device_param->d_root_css_buf; - device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf; + if (data.words_cnt == 0) + { + logfile_sub_msg ("STOP"); - device_param->kernel_params_mp_buf64[3] = 0; - device_param->kernel_params_mp_buf32[4] = mask_ctx->css_cnt; - device_param->kernel_params_mp_buf32[5] = 0; - device_param->kernel_params_mp_buf32[6] = 0; - device_param->kernel_params_mp_buf32[7] = 0; + continue; + } + } + else if (user_options->attack_mode == ATTACK_MODE_BF) + { + logfile_sub_string (mask_ctx->mask); + } - if (user_options->attack_mode == ATTACK_MODE_HYBRID1) - { - if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1; - } - else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) - { - device_param->kernel_params_mp_buf32[5] = 0; - device_param->kernel_params_mp_buf32[6] = 0; - device_param->kernel_params_mp_buf32[7] = 0; - } + u64 words_base = data.words_cnt; - cl_int CL_err = CL_SUCCESS; + if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) + { + if (rules_ctx->kernel_rules_cnt) + { + words_base /= rules_ctx->kernel_rules_cnt; + } + } + else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) + { + if (data.combs_cnt) + { + words_base /= data.combs_cnt; + } + } + else if (user_options_extra->attack_kern == ATTACK_KERN_BF) + { + if (mask_ctx->bfs_cnt) + { + words_base /= mask_ctx->bfs_cnt; + } + } - for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]); - for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]); - for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]); + data.words_base = words_base; - if (CL_err != CL_SUCCESS) - { - log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err)); + if (user_options->keyspace == true) + { + log_info ("%" PRIu64 "", words_base); - return -1; - } + return 0; + } - CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, mask_ctx->root_css_buf, 0, NULL, NULL); - CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, mask_ctx->markov_css_buf, 0, NULL, NULL); + if (data.words_cur > data.words_base) + { + log_error ("ERROR: Restore value greater keyspace"); - if (CL_err != CL_SUCCESS) - { - log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err)); + return -1; + } - return -1; - } + if (data.words_cur) + { + if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) + { + for (uint i = 0; i < hashes->salts_cnt; i++) + { + data.words_progress_restored[i] = data.words_cur * rules_ctx->kernel_rules_cnt; } } - else if (user_options->attack_mode == ATTACK_MODE_BF) + else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) { - mask_ctx->css_buf = mp_gen_css (mask_ctx->mask, strlen (mask_ctx->mask), mask_ctx->mp_sys, mask_ctx->mp_usr, &mask_ctx->css_cnt, hashconfig, user_options); - - if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) + for (uint i = 0; i < hashes->salts_cnt; i++) + { + data.words_progress_restored[i] = data.words_cur * data.combs_cnt; + } + } + else if (user_options_extra->attack_kern == ATTACK_KERN_BF) + { + for (uint i = 0; i < hashes->salts_cnt; i++) { - u32 css_cnt_unicode = mask_ctx->css_cnt * 2; + data.words_progress_restored[i] = data.words_cur * mask_ctx->bfs_cnt; + } + } + } - cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t)); + /* + * Update dictionary statistic + */ - for (uint i = 0, j = 0; i < mask_ctx->css_cnt; i += 1, j += 2) - { - memcpy (&css_buf_unicode[j + 0], &mask_ctx->css_buf[i], sizeof (cs_t)); + dictstat_write (dictstat_ctx); - css_buf_unicode[j + 1].cs_buf[0] = 0; - css_buf_unicode[j + 1].cs_len = 1; - } + /** + * Update loopback file + */ - myfree (mask_ctx->css_buf); + if (user_options->loopback == true) + { + loopback_write_open (loopback_ctx, induct_ctx->root_directory); + } - mask_ctx->css_buf = css_buf_unicode; - mask_ctx->css_cnt = css_cnt_unicode; - } + /** + * some algorithms have a maximum kernel-loops count + */ + + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode) + if (device_param->skipped) continue; - uint mask_min = pw_min; - uint mask_max = pw_max; + if (device_param->kernel_loops_min < device_param->kernel_loops_max) + { + u32 innerloop_cnt = 0; - if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) + if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { - mask_min *= 2; - mask_max *= 2; + if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = rules_ctx->kernel_rules_cnt; + else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt; + else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = mask_ctx->bfs_cnt; + } + else + { + innerloop_cnt = hashes->salts_buf[0].salt_iter; } - if ((mask_ctx->css_cnt < mask_min) || (mask_ctx->css_cnt > mask_max)) + if ((innerloop_cnt >= device_param->kernel_loops_min) && + (innerloop_cnt <= device_param->kernel_loops_max)) { - if (mask_ctx->css_cnt < mask_min) - { - log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask_ctx->mask); - } + device_param->kernel_loops_max = innerloop_cnt; + } + } + } - if (mask_ctx->css_cnt > mask_max) - { - log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask_ctx->mask); - } + /** + * create autotune threads + */ - // skip to next mask + hc_thread_t *c_threads = (hc_thread_t *) mycalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t)); - logfile_sub_msg ("STOP"); + opencl_ctx->devices_status = STATUS_AUTOTUNE; - continue; - } + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - u32 css_cnt_orig = mask_ctx->css_cnt; + hc_thread_create (c_threads[device_id], thread_autotune, device_param); + } - if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH) - { - if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT) - { - uint salt_len = (uint) hashes->salts_buf[0].salt_len; - char *salt_buf = (char *) hashes->salts_buf[0].salt_buf; + hc_thread_wait (opencl_ctx->devices_cnt, c_threads); - uint css_cnt_salt = mask_ctx->css_cnt + salt_len; + /* + * Inform user about possible slow speeds + */ - cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t)); + uint hardware_power_all = 0; - memcpy (css_buf_salt, mask_ctx->css_buf, mask_ctx->css_cnt * sizeof (cs_t)); + uint kernel_power_all = 0; - for (uint i = 0, j = mask_ctx->css_cnt; i < salt_len; i++, j++) - { - css_buf_salt[j].cs_buf[0] = salt_buf[i]; - css_buf_salt[j].cs_len = 1; - } + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - myfree (mask_ctx->css_buf); + hardware_power_all += device_param->hardware_power; - mask_ctx->css_buf = css_buf_salt; - mask_ctx->css_cnt = css_cnt_salt; - } - } + kernel_power_all += device_param->kernel_power; + } - uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } }; + data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices - mp_css_to_uniq_tbl (mask_ctx->css_cnt, mask_ctx->css_buf, uniq_tbls); + data.kernel_power_all = kernel_power_all; - sp_tbl_to_css (mask_ctx->root_table_buf, mask_ctx->markov_table_buf, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, user_options->markov_threshold, uniq_tbls); + if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK)) + { + if (data.words_base < kernel_power_all) + { + if (user_options->quiet == false) + { + clear_prompt (); - data.words_cnt = sp_get_sum (0, mask_ctx->css_cnt, mask_ctx->root_css_buf); + log_info ("ATTENTION!"); + log_info (" The wordlist or mask you are using is too small."); + log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s)."); + log_info (" The cracking speed will drop."); + log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed"); + log_info (""); + } + } + } - // copy + args + /** + * create cracker threads + */ - uint css_cnt_l = mask_ctx->css_cnt; - uint css_cnt_r; + /* still needed ? + if (initial_restore_done == false) + { + if (user_options->restore_disable == false) cycle_restore (restore_ctx, opencl_ctx); - if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) - { - if (css_cnt_orig < 6) - { - css_cnt_r = 1; - } - else if (css_cnt_orig == 6) - { - css_cnt_r = 2; - } - else - { - if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE) - { - if (css_cnt_orig == 8 || css_cnt_orig == 10) - { - css_cnt_r = 2; - } - else - { - css_cnt_r = 4; - } - } - else - { - if ((mask_ctx->css_buf[0].cs_len * mask_ctx->css_buf[1].cs_len * mask_ctx->css_buf[2].cs_len) > 256) - { - css_cnt_r = 3; - } - else - { - css_cnt_r = 4; - } - } - } - } - else - { - css_cnt_r = 1; + initial_restore_done = true; + } + */ - /* unfinished code? - int sum = css_buf[css_cnt_r - 1].cs_len; + opencl_ctx->devices_status = STATUS_RUNNING; - for (uint i = 1; i < 4 && i < css_cnt; i++) - { - if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes + hc_timer_set (&data.timer_running); - css_cnt_r++; + if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK)) + { + if ((user_options->quiet == false) && (user_options->status == false) && (user_options->benchmark == false)) + { + if (user_options->quiet == false) send_prompt (); + } + } + else if (user_options_extra->wordlist_mode == WL_MODE_STDIN) + { + if (user_options->quiet == false) log_info ("Starting attack in stdin mode..."); + if (user_options->quiet == false) log_info (""); + } - sum *= css_buf[css_cnt_r - 1].cs_len; - } - */ - } + time_t runtime_start; - css_cnt_l -= css_cnt_r; + time (&runtime_start); - mask_ctx->bfs_cnt = sp_get_sum (0, css_cnt_r, mask_ctx->root_css_buf); + data.runtime_start = runtime_start; - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + data.prepare_time = runtime_start - data.prepare_start; - if (device_param->skipped) continue; + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf; - device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf; - device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf; + if (user_options_extra->wordlist_mode == WL_MODE_STDIN) + { + hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param); + } + else + { + hc_thread_create (c_threads[device_id], thread_calc, device_param); + } + } - device_param->kernel_params_mp_l_buf64[3] = 0; - device_param->kernel_params_mp_l_buf32[4] = css_cnt_l; - device_param->kernel_params_mp_l_buf32[5] = css_cnt_r; - device_param->kernel_params_mp_l_buf32[6] = 0; - device_param->kernel_params_mp_l_buf32[7] = 0; - device_param->kernel_params_mp_l_buf32[8] = 0; + hc_thread_wait (opencl_ctx->devices_cnt, c_threads); - if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1; - if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1; + local_free (c_threads); - device_param->kernel_params_mp_r[0] = &device_param->d_bfs; - device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf; - device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf; + if ((opencl_ctx->devices_status != STATUS_CRACKED) + && (opencl_ctx->devices_status != STATUS_ABORTED) + && (opencl_ctx->devices_status != STATUS_QUIT) + && (opencl_ctx->devices_status != STATUS_BYPASS)) + { + opencl_ctx->devices_status = STATUS_EXHAUSTED; + } - device_param->kernel_params_mp_r_buf64[3] = 0; - device_param->kernel_params_mp_r_buf32[4] = css_cnt_r; - device_param->kernel_params_mp_r_buf32[5] = 0; - device_param->kernel_params_mp_r_buf32[6] = 0; - device_param->kernel_params_mp_r_buf32[7] = 0; + if (opencl_ctx->devices_status == STATUS_EXHAUSTED) + { + rd->words_cur = 0; + } - cl_int CL_err = CL_SUCCESS; + logfile_sub_var_uint ("status-after-work", opencl_ctx->devices_status); - for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]); - for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]); - for (uint i = 4; i < 9; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]); + if (induct_ctx->induction_dictionaries_cnt) + { + unlink (induct_ctx->induction_dictionaries[0]); + } - for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]); - for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]); - for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (opencl_ctx->ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]); + myfree (induct_ctx->induction_dictionaries); - if (CL_err != CL_SUCCESS) - { - log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err)); + induct_ctx_scan (induct_ctx); - return -1; - } + if (user_options->benchmark == true) + { + status_benchmark (opencl_ctx, hashconfig, user_options); - CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, mask_ctx->root_css_buf, 0, NULL, NULL); - CL_err |= hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, mask_ctx->markov_css_buf, 0, NULL, NULL); + log_info (""); + } + else + { + if (user_options->quiet == false) + { + clear_prompt (); - if (CL_err != CL_SUCCESS) - { - log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err)); + status_display (opencl_ctx, hashconfig, hashes, restore_ctx, user_options, user_options_extra, rules_ctx, mask_ctx); - return -1; - } + log_info (""); + } + else + { + if (user_options->status == true) + { + status_display (opencl_ctx, hashconfig, hashes, restore_ctx, user_options, user_options_extra, rules_ctx, mask_ctx); + + log_info (""); } } } - /** - * update induction directory scan - */ - - induct_ctx_scan (induct_ctx); - - /** - * prevent the user from using --skip/--limit together w/ maskfile and or dictfile - */ - - if (user_options->skip != 0 || user_options->limit != 0) + if (induct_ctx->induction_dictionaries_cnt) { - if ((mask_ctx->masks_cnt > 1) || (dictcnt > 1)) - { - log_error ("ERROR: --skip/--limit are not supported with --increment or mask files"); + // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time) - return -1; - } + dictpos--; } /** - * prevent the user from using --keyspace together w/ maskfile and or dictfile + * Update loopback file */ - if (user_options->keyspace == true) + if (user_options->loopback == true) { - if ((mask_ctx->masks_cnt > 1) || (dictcnt > 1)) - { - log_error ("ERROR: --keyspace is not supported with --increment or mask files"); - - return -1; - } + loopback_write_close (loopback_ctx); } - for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++) - { - if (opencl_ctx->run_main_level3 == false) break; + time_t runtime_stop; - //opencl_ctx->run_main_level1 = true; - //opencl_ctx->run_main_level2 = true; - //opencl_ctx->run_main_level3 = true; - opencl_ctx->run_thread_level1 = true; - opencl_ctx->run_thread_level2 = true; + time (&runtime_stop); - rd->dictpos = dictpos; + data.runtime_stop = runtime_stop; - logfile_generate_subid (logfile_ctx); + logfile_sub_uint (runtime_start); + logfile_sub_uint (runtime_stop); - logfile_sub_msg ("START"); + time (&data.prepare_start); - memset (data.words_progress_done, 0, hashes->salts_cnt * sizeof (u64)); - memset (data.words_progress_rejected, 0, hashes->salts_cnt * sizeof (u64)); - memset (data.words_progress_restored, 0, hashes->salts_cnt * sizeof (u64)); + logfile_sub_msg ("STOP"); - memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t)); + // finalize task - data.cpt_pos = 0; + if (opencl_ctx->run_main_level3 == false) break; + } - data.cpt_start = time (NULL); + // free memory - data.cpt_total = 0; + global_free (words_progress_done); + global_free (words_progress_rejected); + global_free (words_progress_restored); - data.words_cur = 0; + return 0; +} - if (rd->words_cur) - { - data.words_cur = rd->words_cur; +static int outer_loop (user_options_t *user_options, user_options_extra_t *user_options_extra, restore_ctx_t *restore_ctx, folder_config_t *folder_config, logfile_ctx_t *logfile_ctx, tuning_db_t *tuning_db, induct_ctx_t *induct_ctx, outcheck_ctx_t *outcheck_ctx, outfile_ctx_t *outfile_ctx, potfile_ctx_t *potfile_ctx, rules_ctx_t *rules_ctx, dictstat_ctx_t *dictstat_ctx, loopback_ctx_t *loopback_ctx, opencl_ctx_t *opencl_ctx) +{ + opencl_ctx->devices_status = STATUS_INIT; - user_options->skip = 0; - } + //opencl_ctx->run_main_level1 = true; + opencl_ctx->run_main_level2 = true; + opencl_ctx->run_main_level3 = true; + opencl_ctx->run_thread_level1 = true; + opencl_ctx->run_thread_level2 = true; - if (user_options->skip) - { - data.words_cur = user_options->skip; + /* + * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass' + * the following algos are skipped entirely + * still needed? there's no more bypass in benchmark mode + * also there's no signs of special benchmark handling in the branch + */ - user_options->skip = 0; - } + /* + if (algorithm_pos > 0) + { + local_free (rd); - data.ms_paused = 0; + rd = init_restore (argc, argv, user_options); - data.kernel_power_final = 0; + data.rd = rd; + } + */ - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + /** + * setup prepare timer + */ - if (device_param->skipped) continue; + time (&data.prepare_start); - device_param->speed_pos = 0; + /** + * setup variables and buffers depending on hash_mode + */ - memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64)); - memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double)); + hashconfig_t *hashconfig = (hashconfig_t *) mymalloc (sizeof (hashconfig_t)); - device_param->exec_pos = 0; + data.hashconfig = hashconfig; - memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double)); + const int rc_hashconfig = hashconfig_init (hashconfig, user_options); - device_param->outerloop_pos = 0; - device_param->outerloop_left = 0; - device_param->innerloop_pos = 0; - device_param->innerloop_left = 0; + if (rc_hashconfig == -1) return -1; - // some more resets: + /** + * potfile show/left depends on hash_mode, so it's called here first time + */ - if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws); + if (user_options->show == true || user_options->left == true) + { + outfile_write_open (outfile_ctx); - device_param->pws_cnt = 0; + SUPPRESS_OUTPUT = 1; - device_param->words_off = 0; - device_param->words_done = 0; - } + potfile_read_open (potfile_ctx); - // figure out some workload + potfile_read_parse (potfile_ctx, hashconfig); - if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) - { - if (user_options_extra->wordlist_mode == WL_MODE_FILE) - { - char *dictfile = NULL; + potfile_read_close (potfile_ctx); - if (induct_ctx->induction_dictionaries_cnt) - { - dictfile = induct_ctx->induction_dictionaries[0]; - } - else - { - dictfile = dictfiles[dictpos]; - } + SUPPRESS_OUTPUT = 0; + } - data.dictfile = dictfile; + /** + * load hashes, stage 1 + */ - logfile_sub_string (dictfile); + hashes_t *hashes = (hashes_t *) mymalloc (sizeof (hashes_t)); - for (uint i = 0; i < user_options->rp_files_cnt; i++) - { - logfile_sub_var_string ("rulefile", user_options->rp_files[i]); - } + data.hashes = hashes; - FILE *fd2 = fopen (dictfile, "rb"); + const int rc_hashes_init_stage1 = hashes_init_stage1 (hashes, hashconfig, potfile_ctx, outfile_ctx, user_options, restore_ctx->argv[user_options_extra->optind]); - if (fd2 == NULL) - { - log_error ("ERROR: %s: %s", dictfile, strerror (errno)); + if (rc_hashes_init_stage1 == -1) return -1; - return -1; - } + if ((user_options->keyspace == false) && (user_options->stdout_flag == false) && (user_options->opencl_info == false)) + { + if (hashes->hashes_cnt == 0) + { + log_error ("ERROR: No hashes loaded"); - data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); + return -1; + } + } - fclose (fd2); + /** + * potfile show/left final + */ - if (data.words_cnt == 0) - { - logfile_sub_msg ("STOP"); + if (user_options->show == true || user_options->left == true) + { + outfile_write_close (outfile_ctx); - continue; - } - } - } - else if (user_options->attack_mode == ATTACK_MODE_COMBI) - { - char *dictfile = data.dictfile; - char *dictfile2 = data.dictfile2; + potfile_hash_free (potfile_ctx, hashconfig); - logfile_sub_string (dictfile); - logfile_sub_string (dictfile2); + //if (user_options->quiet == false) log_info_nn (""); - if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT) - { - FILE *fd2 = fopen (dictfile, "rb"); + return 0; + } - if (fd2 == NULL) - { - log_error ("ERROR: %s: %s", dictfile, strerror (errno)); + /** + * Potfile removes + */ - return -1; - } + int potfile_remove_cracks = 0; - data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); + if (user_options->potfile_disable == 0) + { + if (user_options->quiet == false) log_info_nn ("Comparing hashes with potfile entries..."); - fclose (fd2); - } - else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT) - { - FILE *fd2 = fopen (dictfile2, "rb"); + potfile_remove_cracks = potfile_remove_parse (potfile_ctx, hashconfig, hashes); + } - if (fd2 == NULL) - { - log_error ("ERROR: %s: %s", dictfile2, strerror (errno)); + /** + * load hashes, stage 2, remove duplicates, build base structure + */ - return -1; - } + const u32 hashes_cnt_orig = hashes->hashes_cnt; - data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile2, dictstat_ctx); + const int rc_hashes_init_stage2 = hashes_init_stage2 (hashes, hashconfig, opencl_ctx, user_options); - fclose (fd2); - } + if (rc_hashes_init_stage2 == -1) return -1; - if (data.words_cnt == 0) - { - logfile_sub_msg ("STOP"); + /** + * load hashes, stage 3, automatic Optimizers + */ - continue; - } - } - else if ((user_options->attack_mode == ATTACK_MODE_HYBRID1) || (user_options->attack_mode == ATTACK_MODE_HYBRID2)) - { - char *dictfile = NULL; + const int rc_hashes_init_stage3 = hashes_init_stage3 (hashes, hashconfig, user_options); - if (induct_ctx->induction_dictionaries_cnt) - { - dictfile = induct_ctx->induction_dictionaries[0]; - } - else - { - dictfile = dictfiles[dictpos]; - } + if (rc_hashes_init_stage3 == -1) return -1; - data.dictfile = dictfile; + hashes_logger (hashes, logfile_ctx); - logfile_sub_string (dictfile); - logfile_sub_string (mask_ctx->mask); + /** + * bitmaps + */ - FILE *fd2 = fopen (dictfile, "rb"); + bitmap_ctx_t *bitmap_ctx = (bitmap_ctx_t *) mymalloc (sizeof (bitmap_ctx_t)); - if (fd2 == NULL) - { - log_error ("ERROR: %s: %s", dictfile, strerror (errno)); + data.bitmap_ctx = bitmap_ctx; - return -1; - } + bitmap_ctx_init (bitmap_ctx, user_options, hashconfig, hashes); - data.words_cnt = count_words (wl_data, user_options, user_options_extra, rules_ctx, fd2, dictfile, dictstat_ctx); + /** + * charsets : keep them together for more easy maintainnce + */ - fclose (fd2); + mask_ctx_t *mask_ctx = (mask_ctx_t *) mymalloc (sizeof (mask_ctx_t)); - if (data.words_cnt == 0) + data.mask_ctx = mask_ctx; + + const int rc_mask_init = mask_ctx_init (mask_ctx, user_options, user_options_extra, folder_config, restore_ctx, hashconfig); + + if (rc_mask_init == -1) return -1; + + /** + * HM devices: init + */ + + hm_attrs_t hm_adapters_adl[DEVICES_MAX]; + hm_attrs_t hm_adapters_nvapi[DEVICES_MAX]; + hm_attrs_t hm_adapters_nvml[DEVICES_MAX]; + hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX]; + + memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl)); + memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi)); + memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml)); + memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl)); + + if (user_options->gpu_temp_disable == false) + { + ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR)); + NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR)); + NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR)); + XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR)); + + data.hm_adl = NULL; + data.hm_nvapi = NULL; + data.hm_nvml = NULL; + data.hm_xnvctrl = NULL; + + if ((opencl_ctx->need_nvml == true) && (nvml_init (nvml) == 0)) + { + data.hm_nvml = nvml; + } + + if (data.hm_nvml) + { + if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS) + { + HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 }; + + int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle); + + int tmp_out = 0; + + for (int i = 0; i < tmp_in; i++) { - logfile_sub_msg ("STOP"); + hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i]; + } - continue; + for (int i = 0; i < tmp_out; i++) + { + unsigned int speed; + + if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1; + + // doesn't seem to create any advantages + //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS); + //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON); } } - else if (user_options->attack_mode == ATTACK_MODE_BF) - { - logfile_sub_string (mask_ctx->mask); - } + } - u64 words_base = data.words_cnt; + if ((opencl_ctx->need_nvapi == true) && (nvapi_init (nvapi) == 0)) + { + data.hm_nvapi = nvapi; + } - if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) + if (data.hm_nvapi) + { + if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK) { - if (rules_ctx->kernel_rules_cnt) + HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 }; + + int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle); + + int tmp_out = 0; + + for (int i = 0; i < tmp_in; i++) { - words_base /= rules_ctx->kernel_rules_cnt; + hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i]; } } - else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) + } + + if ((opencl_ctx->need_xnvctrl == true) && (xnvctrl_init (xnvctrl) == 0)) + { + data.hm_xnvctrl = xnvctrl; + } + + if (data.hm_xnvctrl) + { + if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0) { - if (data.combs_cnt) + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) { - words_base /= data.combs_cnt; + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + + if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + + hm_adapters_xnvctrl[device_id].xnvctrl = device_id; + + int speed = 0; + + if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1; } } - else if (user_options_extra->attack_kern == ATTACK_KERN_BF) + } + + if ((opencl_ctx->need_adl == true) && (adl_init (adl) == 0)) + { + data.hm_adl = adl; + } + + if (data.hm_adl) + { + if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK) { - if (mask_ctx->bfs_cnt) + // total number of adapters + + int hm_adapters_num; + + if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1; + + // adapter info + + LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num); + + if (lpAdapterInfo == NULL) return -1; + + // get a list (of ids of) valid/usable adapters + + int num_adl_adapters = 0; + + u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo); + + if (num_adl_adapters > 0) { - words_base /= mask_ctx->bfs_cnt; + hc_thread_mutex_lock (mux_hwmon); + + // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all); + + hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + + hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + + hc_thread_mutex_unlock (mux_hwmon); } + + myfree (valid_adl_device_list); + myfree (lpAdapterInfo); } + } - data.words_base = words_base; + if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) + { + user_options->gpu_temp_disable = true; + } + } + + /** + * OpenCL devices: allocate buffer for device specific information + */ + + ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (opencl_ctx->devices_cnt, sizeof (ADLOD6MemClockState)); + + int *od_power_control_status = (int *) mycalloc (opencl_ctx->devices_cnt, sizeof (int)); - if (user_options->keyspace == true) + unsigned int *nvml_power_limit = (unsigned int *) mycalloc (opencl_ctx->devices_cnt, sizeof (unsigned int)); + + /** + * Wordlist allocate buffer + */ + + wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t)); + + wl_data_init (wl_data, user_options, hashconfig); + + /** + * User-defined GPU temp handling + */ + + if (user_options->gpu_temp_disable == true) + { + user_options->gpu_temp_abort = 0; + user_options->gpu_temp_retain = 0; + } + + /** + * enable custom signal handler(s) + */ + + if (user_options->benchmark == false) + { + hc_signal (sigHandler_default); + } + else + { + hc_signal (sigHandler_benchmark); + } + + /** + * inform the user + */ + + if (user_options->quiet == false) + { + log_info ("Hashes: %u digests; %u unique digests, %u unique salts", hashes_cnt_orig, hashes->digests_cnt, hashes->salts_cnt); + + log_info ("Bitmaps: %u bits, %u entries, 0x%08x mask, %u bytes, %u/%u rotates", bitmap_ctx->bitmap_bits, bitmap_ctx->bitmap_nums, bitmap_ctx->bitmap_mask, bitmap_ctx->bitmap_size, bitmap_ctx->bitmap_shift1, bitmap_ctx->bitmap_shift2); + + if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) + { + log_info ("Rules: %u", rules_ctx->kernel_rules_cnt); + } + + if (user_options->quiet == false) log_info (""); + + if (hashconfig->opti_type) + { + log_info ("Applicable Optimizers:"); + + for (uint i = 0; i < 32; i++) { - log_info ("%" PRIu64 "", words_base); + const uint opti_bit = 1u << i; - return 0; + if (hashconfig->opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit)); } + } + + if (user_options->quiet == false) log_info (""); + + /** + * Watchdog and Temperature balance + */ + + if (user_options->gpu_temp_disable == false && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) + { + log_info ("Watchdog: Hardware Monitoring Interface not found on your system"); + } + + if (user_options->gpu_temp_abort == 0) + { + log_info ("Watchdog: Temperature abort trigger disabled"); + } + else + { + log_info ("Watchdog: Temperature abort trigger set to %uc", user_options->gpu_temp_abort); + } - if (data.words_cur > data.words_base) + if (user_options->gpu_temp_retain == 0) + { + log_info ("Watchdog: Temperature retain trigger disabled"); + } + else + { + log_info ("Watchdog: Temperature retain trigger set to %uc", user_options->gpu_temp_retain); + } + + if (user_options->quiet == false) log_info (""); + } + + /** + * HM devices: copy + */ + + if (user_options->gpu_temp_disable == false) + { + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + + if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + + if (device_param->skipped) continue; + + const uint platform_devices_id = device_param->platform_devices_id; + + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - log_error ("ERROR: Restore value greater keyspace"); + data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl; + data.hm_device[device_id].nvapi = 0; + data.hm_device[device_id].nvml = 0; + data.hm_device[device_id].xnvctrl = 0; + data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version; + data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = 0; + } - return -1; + if (device_param->device_vendor_id == VENDOR_ID_NV) + { + data.hm_device[device_id].adl = 0; + data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi; + data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml; + data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl; + data.hm_device[device_id].od_version = 0; + data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = 0; } + } + } + + /** + * powertune on user request + */ + + if (user_options->powertune_enable == true) + { + hc_thread_mutex_lock (mux_hwmon); + + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - if (data.words_cur) + if (device_param->skipped) continue; + + if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_AMD) { - if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) + /** + * Temporary fix: + * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff + * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately + * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem) + * Driver / ADL bug? + */ + + if (data.hm_device[device_id].od_version == 6) { - for (uint i = 0; i < hashes->salts_cnt; i++) + int ADL_rc; + + // check powertune capabilities first, if not available then skip device + + int powertune_supported = 0; + + if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK) { - data.words_progress_restored[i] = data.words_cur * rules_ctx->kernel_rules_cnt; + log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); + + return -1; } - } - else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) - { - for (uint i = 0; i < hashes->salts_cnt; i++) + + // first backup current value, we will restore it later + + if (powertune_supported != 0) { - data.words_progress_restored[i] = data.words_cur * data.combs_cnt; + // powercontrol settings + + ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK) + { + ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]); + } + + if (ADL_rc != ADL_OK) + { + log_error ("ERROR: Failed to get current ADL PowerControl settings"); + + return -1; + } + + if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) + { + log_error ("ERROR: Failed to set new ADL PowerControl values"); + + return -1; + } + + // clocks + + memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState)); + + od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2; + + if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK) + { + log_error ("ERROR: Failed to get ADL memory and engine clock frequency"); + + return -1; + } + + // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings + + ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK) + { + log_error ("ERROR: Failed to get ADL device capabilities"); + + return -1; + } + + int engine_clock_max = (int) (0.6666 * caps.sEngineClockRange.iMax); + int memory_clock_max = (int) (0.6250 * caps.sMemoryClockRange.iMax); + + int warning_trigger_engine = (int) (0.25 * engine_clock_max); + int warning_trigger_memory = (int) (0.25 * memory_clock_max); + + int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; + int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; + + // warning if profile has too low max values + + if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine) + { + log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance"); + } + + if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory) + { + log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance"); + } + + ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); + + performance_state->iNumberOfPerformanceLevels = 2; + + performance_state->aLevels[0].iEngineClock = engine_clock_profile_max; + performance_state->aLevels[1].iEngineClock = engine_clock_profile_max; + performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max; + performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max; + + if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + { + log_info ("ERROR: Failed to set ADL performance state"); + + return -1; + } + + local_free (performance_state); } - } - else if (user_options_extra->attack_kern == ATTACK_KERN_BF) - { - for (uint i = 0; i < hashes->salts_cnt; i++) + + // set powertune value only + + if (powertune_supported != 0) { - data.words_progress_restored[i] = data.words_cur * mask_ctx->bfs_cnt; + // powertune set + ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK) + { + log_error ("ERROR: Failed to get current ADL PowerControl settings"); + + return -1; + } + + if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) + { + log_error ("ERROR: Failed to set new ADL PowerControl values"); + + return -1; + } } } } - /* - * Update dictionary statistic - */ - - dictstat_write (dictstat_ctx); - - /** - * Update loopback file - */ - - if (user_options->loopback == true) + if (opencl_ctx->devices_param[device_id].device_vendor_id == VENDOR_ID_NV) { - loopback_write_open (loopback_ctx, induct_ctx->root_directory); - } + // first backup current value, we will restore it later - /** - * some algorithms have a maximum kernel-loops count - */ + unsigned int limit; - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + bool powertune_supported = false; - if (device_param->skipped) continue; + if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS) + { + powertune_supported = true; + } + + // if backup worked, activate the maximum allowed - if (device_param->kernel_loops_min < device_param->kernel_loops_max) + if (powertune_supported == true) { - u32 innerloop_cnt = 0; + unsigned int minLimit; + unsigned int maxLimit; - if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) - { - if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = rules_ctx->kernel_rules_cnt; - else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt; - else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = mask_ctx->bfs_cnt; - } - else + if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS) { - innerloop_cnt = hashes->salts_buf[0].salt_iter; - } + if (maxLimit > 0) + { + if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS) + { + // now we can be sure we need to reset later - if ((innerloop_cnt >= device_param->kernel_loops_min) && - (innerloop_cnt <= device_param->kernel_loops_max)) - { - device_param->kernel_loops_max = innerloop_cnt; + nvml_power_limit[device_id] = limit; + } + } } } } + } - /** - * create autotune threads - */ + hc_thread_mutex_unlock (mux_hwmon); + } - hc_thread_t *c_threads = (hc_thread_t *) mycalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t)); + #if defined (DEBUG) + if (user_options->benchmark == true) log_info ("Hashmode: %d", hashconfig->hash_mode); + #endif - opencl_ctx->devices_status = STATUS_AUTOTUNE; + if (user_options->quiet == false) log_info_nn ("Initializing device kernels and memory..."); - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + /* + session_ctx_t *session_ctx = (session_ctx_t *) mymalloc (sizeof (session_ctx_t)); - hc_thread_create (c_threads[device_id], thread_autotune, device_param); - } + data.session_ctx = session_ctx; - hc_thread_wait (opencl_ctx->devices_cnt, c_threads); + session_ctx_init (session_ctx); + */ - /* - * Inform user about possible slow speeds - */ + opencl_session_begin (opencl_ctx, hashconfig, hashes, rules_ctx, user_options, user_options_extra, folder_config, bitmap_ctx, tuning_db); - uint hardware_power_all = 0; + if (user_options->quiet == false) log_info_nn (""); - uint kernel_power_all = 0; + /** + * Store initial fanspeed if gpu_temp_retain is enabled + */ + if (user_options->gpu_temp_disable == false) + { + if (user_options->gpu_temp_retain) + { for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) { hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; - hardware_power_all += device_param->hardware_power; + if (device_param->skipped) continue; - kernel_power_all += device_param->kernel_power; - } + hc_thread_mutex_lock (mux_hwmon); - data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices + if (data.hm_device[device_id].fan_get_supported == true) + { + const int fanspeed = hm_get_fanspeed_with_device_id (opencl_ctx, device_id); + const int fanpolicy = hm_get_fanpolicy_with_device_id (opencl_ctx, device_id); - data.kernel_power_all = kernel_power_all; + // we also set it to tell the OS we take control over the fan and it's automatic controller + // if it was set to automatic. we do not control user-defined fanspeeds. - if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK)) - { - if (data.words_base < kernel_power_all) - { - if (user_options->quiet == false) + if (fanpolicy == 1) + { + data.hm_device[device_id].fan_set_supported = true; + + int rc = -1; + + if (device_param->device_vendor_id == VENDOR_ID_AMD) + { + rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1); + } + else if (device_param->device_vendor_id == VENDOR_ID_NV) + { + #if defined (__linux__) + rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE); + #endif + + #if defined (_WIN) + rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1); + #endif + } + + if (rc == 0) + { + data.hm_device[device_id].fan_set_supported = 1; + } + else + { + log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1); + + data.hm_device[device_id].fan_set_supported = 0; + } + } + else { - clear_prompt (); - - log_info ("ATTENTION!"); - log_info (" The wordlist or mask you are using is too small."); - log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s)."); - log_info (" The cracking speed will drop."); - log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed"); - log_info (""); + data.hm_device[device_id].fan_set_supported = 0; } } + + hc_thread_mutex_unlock (mux_hwmon); } + } + } - /** - * create cracker threads - */ + /** + * In benchmark-mode, inform user which algorithm is checked + */ - /* still needed ? - if (initial_restore_done == false) - { - if (user_options->restore_disable == false) cycle_restore (restore_ctx, opencl_ctx); + if (user_options->benchmark == true) + { + if (user_options->machine_readable == false) + { + char *hash_type = strhashtype (hashconfig->hash_mode); // not a bug - initial_restore_done = true; - } - */ + log_info ("Hashtype: %s", hash_type); + log_info (""); + } + } - opencl_ctx->devices_status = STATUS_RUNNING; + /** + * weak hash check is the first to write to potfile, so open it for writing from here + */ - hc_timer_set (&data.timer_running); + potfile_write_open (potfile_ctx); - if ((user_options_extra->wordlist_mode == WL_MODE_FILE) || (user_options_extra->wordlist_mode == WL_MODE_MASK)) - { - if ((user_options->quiet == false) && (user_options->status == false) && (user_options->benchmark == false)) - { - if (user_options->quiet == false) send_prompt (); - } - } - else if (user_options_extra->wordlist_mode == WL_MODE_STDIN) - { - if (user_options->quiet == false) log_info ("Starting attack in stdin mode..."); - if (user_options->quiet == false) log_info (""); - } + /** + * weak hash check + */ - time_t runtime_start; + if (user_options->weak_hash_threshold >= hashes->salts_cnt) + { + hc_device_param_t *device_param = NULL; - time (&runtime_start); + for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) + { + device_param = &opencl_ctx->devices_param[device_id]; - data.runtime_start = runtime_start; + if (device_param->skipped) continue; - data.prepare_time = runtime_start - prepare_start; + break; + } - for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) - { - hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; + if (user_options->quiet == false) log_info_nn ("Checking for weak hashes..."); - if (user_options_extra->wordlist_mode == WL_MODE_STDIN) - { - hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param); - } - else - { - hc_thread_create (c_threads[device_id], thread_calc, device_param); - } - } + for (uint salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++) + { + weak_hash_check (opencl_ctx, device_param, user_options, user_options_extra, rules_ctx, hashconfig, hashes, salt_pos); + } + } - hc_thread_wait (opencl_ctx->devices_cnt, c_threads); + /** + * status and monitor threads + */ - local_free (c_threads); + uint inner_threads_cnt = 0; - if ((opencl_ctx->devices_status != STATUS_CRACKED) - && (opencl_ctx->devices_status != STATUS_ABORTED) - && (opencl_ctx->devices_status != STATUS_QUIT) - && (opencl_ctx->devices_status != STATUS_BYPASS)) - { - opencl_ctx->devices_status = STATUS_EXHAUSTED; - } + hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); - if (opencl_ctx->devices_status == STATUS_EXHAUSTED) - { - rd->words_cur = 0; - } + data.shutdown_inner = 0; - logfile_sub_var_uint ("status-after-work", opencl_ctx->devices_status); + /** + * Outfile remove + */ - if (induct_ctx->induction_dictionaries_cnt) - { - unlink (induct_ctx->induction_dictionaries[0]); - } + if (user_options->keyspace == false && user_options->benchmark == false && user_options->stdout_flag == false) + { + hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL); - myfree (induct_ctx->induction_dictionaries); + inner_threads_cnt++; - induct_ctx_scan (induct_ctx); + if (outcheck_ctx->enabled == true) + { + hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL); - if (user_options->benchmark == true) - { - status_benchmark (opencl_ctx, hashconfig, user_options); + inner_threads_cnt++; + } + } + /** + * main loop + */ + + if (user_options->quiet == false) + { + if (potfile_remove_cracks > 0) + { + if (potfile_remove_cracks == 1) + { + log_info ("INFO: Removed 1 hash found in potfile"); log_info (""); } else { - if (user_options->quiet == false) - { - clear_prompt (); - - status_display (opencl_ctx, hashconfig, hashes, restore_ctx, user_options, user_options_extra, rules_ctx, mask_ctx); - - log_info (""); - } - else - { - if (user_options->status == true) - { - status_display (opencl_ctx, hashconfig, hashes, restore_ctx, user_options, user_options_extra, rules_ctx, mask_ctx); - - log_info (""); - } - } + log_info ("INFO: Removed %d hashes found in potfile", potfile_remove_cracks); + log_info (""); } + } + } - if (induct_ctx->induction_dictionaries_cnt) - { - // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time) + // still needed? + // bool initial_restore_done = false; - dictpos--; - } + // still needed? + // mask_ctx->masks_cnt = maskcnt; - /** - * Update loopback file - */ + restore_data_t *rd = restore_ctx->rd; - if (user_options->loopback == true) + if (mask_ctx->masks_cnt) + { + for (uint masks_pos = rd->masks_pos; masks_pos < mask_ctx->masks_cnt; masks_pos++) + { + if (masks_pos > rd->masks_pos) { - loopback_write_close (loopback_ctx); + rd->dictpos = 0; } - time_t runtime_stop; - - time (&runtime_stop); - - data.runtime_stop = runtime_stop; - - logfile_sub_uint (runtime_start); - logfile_sub_uint (runtime_stop); + rd->masks_pos = masks_pos; - time (&prepare_start); + mask_ctx->masks_pos = masks_pos; - logfile_sub_msg ("STOP"); + const int rc_inner1_loop = inner1_loop (user_options, user_options_extra, restore_ctx, logfile_ctx, induct_ctx, rules_ctx, dictstat_ctx, loopback_ctx, opencl_ctx, hashconfig, hashes, mask_ctx, wl_data); - // finalize task + if (rc_inner1_loop == -1) return -1; - if (opencl_ctx->run_main_level3 == false) break; + if (opencl_ctx->run_main_level2 == false) break; } + } + else + { + const int rc_inner1_loop = inner1_loop (user_options, user_options_extra, restore_ctx, logfile_ctx, induct_ctx, rules_ctx, dictstat_ctx, loopback_ctx, opencl_ctx, hashconfig, hashes, mask_ctx, wl_data); - if (opencl_ctx->run_main_level2 == false) break; + if (rc_inner1_loop == -1) return -1; } + /* ???????? TODO // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { @@ -2555,6 +2589,7 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ mask_ctx->mask = mask_ctx->masks[0]; } } + */ // if cracked / aborted remove last induction dictionary @@ -2764,8 +2799,6 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ potfile_write_close (potfile_ctx); - wl_data_destroy (wl_data); - bitmap_ctx_destroy (bitmap_ctx); mask_ctx_destroy (mask_ctx); @@ -2774,14 +2807,12 @@ static int outer_loop (user_options_t *user_options, user_options_extra_t *user_ hashconfig_destroy (hashconfig); + wl_data_destroy (wl_data); + local_free (od_clock_mem_status); local_free (od_power_control_status); local_free (nvml_power_limit); - global_free (words_progress_done); - global_free (words_progress_rejected); - global_free (words_progress_restored); - return 0; } diff --git a/src/user_options.c b/src/user_options.c index 85032dc81..c12eee580 100644 --- a/src/user_options.c +++ b/src/user_options.c @@ -463,14 +463,14 @@ int user_options_sanity (user_options_t *user_options, restore_ctx_t *restore_ct return -1; } - if ((user_options->increment == true) && (user_options->increment_min_chgd == true)) + if ((user_options->increment == false) && (user_options->increment_min_chgd == true)) { log_error ("ERROR: Increment-min is only supported combined with increment switch"); return -1; } - if ((user_options->increment == true) && (user_options->increment_max_chgd == true)) + if ((user_options->increment == false) && (user_options->increment_max_chgd == true)) { log_error ("ERROR: Increment-max is only supported combined with increment switch"); @@ -856,6 +856,26 @@ int user_options_extra_init (user_options_t *user_options, restore_ctx_t *restor if (user_options->attack_mode == ATTACK_MODE_BF) { user_options_extra->wordlist_mode = WL_MODE_MASK; + + // default mask + + if (user_options->benchmark == false) + { + if ((user_options_extra->optind + 2) <= restore_ctx->argc) + { + // user provides mask + } + else + { + // prepare default mask charset + + user_options->custom_charset_1 = (char *) "?l?d?u"; + user_options->custom_charset_2 = (char *) "?l?d"; + user_options->custom_charset_3 = (char *) "?l?d*!$@_"; + + user_options->increment = true; + } + } } /* still needed? @@ -868,26 +888,6 @@ int user_options_extra_init (user_options_t *user_options, restore_ctx_t *restor } */ - // default mask - - if (user_options->benchmark == false) - { - if ((user_options_extra->optind + 2) <= restore_ctx->argc) - { - // user provides mask - } - else - { - // prepare default mask charset - - user_options->custom_charset_1 = (char *) "?l?d?u"; - user_options->custom_charset_2 = (char *) "?l?d"; - user_options->custom_charset_3 = (char *) "?l?d*!$@_"; - - user_options->increment = true; - } - } - return 0; }