X-Git-Url: https://www.flypig.org.uk/git/?a=blobdiff_plain;f=src%2Fhashcat.c;h=55a26a09ab87e48306fed720b32383106b9da9e0;hb=106e781a2f2ab691f27868dc86ec467e9a630cb8;hp=20305b64a88e89df207ea2981c69936125519f55;hpb=040bbd416af4a4bae1168bfd7b8cd138a1ef4340;p=hashcat.git diff --git a/src/hashcat.c b/src/hashcat.c index 20305b6..55a26a0 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -164,6 +164,12 @@ double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 }; attr = NULL; \ } +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +#define HC_API_CALL __stdcall +#else +#define HC_API_CALL +#endif + static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] = { 900, @@ -1531,6 +1537,12 @@ void status_display () } #ifdef HAVE_HWMON + + if (data.devices_status == STATUS_EXHAUSTED) return; + if (data.devices_status == STATUS_CRACKED) return; + if (data.devices_status == STATUS_ABORTED) return; + if (data.devices_status == STATUS_QUIT) return; + if (data.gpu_temp_disable == 0) { hc_thread_mutex_lock (mux_adl); @@ -1614,6 +1626,7 @@ void status_display () hc_thread_mutex_unlock (mux_adl); } + #endif // HAVE_HWMON } @@ -2389,42 +2402,6 @@ static void save_hash () unlink (old_hashfile); } -static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all) -{ - // function called only in case kernel_power_all > words_left - - float kernel_power_div = (float) (total_left) / kernel_power_all; - - kernel_power_div += kernel_power_div / 100; - - u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div); - - while (kernel_power_new < total_left) - { - kernel_power_div += kernel_power_div / 100; - - kernel_power_new = (u32) (kernel_power_all * kernel_power_div); - } - - if (data.quiet == 0) - { - clear_prompt (); - - //log_info (""); - - log_info ("INFO: approaching final keyspace, workload adjusted"); - log_info (""); - - fprintf (stdout, "%s", PROMPT); - - fflush (stdout); - } - - //if ((kernel_power_all * kernel_power_div) < 8) return 1; - - return kernel_power_div; -} - static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update) { uint num_elements = num; @@ -3816,7 +3793,7 @@ static void *thread_monitor (void *p) uint status_left = data.status_timer; #ifdef HAVE_HWMON - uint hwmon_check = 0; + uint hwmon_check = 0; int slowdown_warnings = 0; @@ -3884,7 +3861,7 @@ static void *thread_monitor (void *p) #ifdef HAVE_HWMON - if (1) + if (hwmon_check == 1) { hc_thread_mutex_lock (mux_adl); @@ -3894,35 +3871,47 @@ static void *thread_monitor (void *p) if (device_param->skipped) continue; - if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + if (device_param->device_vendor_id == VENDOR_ID_NV) + { + if (data.hm_nvapi) + { + NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 }; + NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 }; - const int temperature = hm_get_temperature_with_device_id (device_id); + perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1); + perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1); - const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown; + hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info); - if (temperature >= threshold) - { - if (slowdown_warnings < 3) - { - if (data.quiet == 0) clear_prompt (); + perfPolicies_status.info_value = perfPolicies_info.info_value; - log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1); + hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status); - if (slowdown_warnings == 2) + if (perfPolicies_status.throttle & 2) { - log_info (""); - } + if (slowdown_warnings < 3) + { + if (data.quiet == 0) clear_prompt (); - if (data.quiet == 0) fprintf (stdout, "%s", PROMPT); - if (data.quiet == 0) fflush (stdout); + log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1); - slowdown_warnings++; + if (slowdown_warnings == 2) + { + log_info (""); + } + + if (data.quiet == 0) fprintf (stdout, "%s", PROMPT); + if (data.quiet == 0) fflush (stdout); + + slowdown_warnings++; + } + } + else + { + slowdown_warnings = 0; + } } } - else - { - slowdown_warnings = 0; - } } hc_thread_mutex_unlock (mux_adl); @@ -4431,14 +4420,43 @@ static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int //} } -static u32 get_power (const u32 kernel_power) +static void set_kernel_power_final (const u64 kernel_power_final) +{ + if (data.quiet == 0) + { + clear_prompt (); + + //log_info (""); + + log_info ("INFO: approaching final keyspace, workload adjusted"); + log_info (""); + + fprintf (stdout, "%s", PROMPT); + + fflush (stdout); + } + + data.kernel_power_final = kernel_power_final; +} + +static u32 get_power (hc_device_param_t *device_param) { - if (data.kernel_power_div) + const u64 kernel_power_final = data.kernel_power_final; + + if (kernel_power_final) { - return (float) kernel_power * data.kernel_power_div; + const double device_factor = (double) device_param->hardware_power / data.hardware_power_all; + + const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor); + + // work should be at least the hardware power available without any accelerator + + const u64 work = MAX (words_left_device, device_param->hardware_power); + + return work; } - return kernel_power; + return device_param->kernel_power; } static uint get_work (hc_device_param_t *device_param, const u64 max) @@ -4450,17 +4468,19 @@ static uint get_work (hc_device_param_t *device_param, const u64 max) device_param->words_off = words_cur; + const u64 kernel_power_all = data.kernel_power_all; + const u64 words_left = words_base - words_cur; - if (data.kernel_power_all > words_left) + if (words_left < kernel_power_all) { - if (data.kernel_power_div == 0) + if (data.kernel_power_final == 0) { - data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all); + set_kernel_power_final (words_left); } } - const u32 kernel_power = get_power (device_param->kernel_power); + const u32 kernel_power = get_power (device_param); uint work = MIN (words_left, kernel_power); @@ -4507,7 +4527,7 @@ static void *thread_calc_stdin (void *p) uint words_cur = 0; - while (words_cur < get_power (device_param->kernel_power)) + while (words_cur < device_param->kernel_power) { char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin); @@ -4541,6 +4561,8 @@ static void *thread_calc_stdin (void *p) continue; } + // hmm that's always the case, or? + if (attack_kern == ATTACK_KERN_STRAIGHT) { if ((line_len < data.pw_min) || (line_len > data.pw_max)) @@ -4557,25 +4579,6 @@ static void *thread_calc_stdin (void *p) continue; } } - else if (attack_kern == ATTACK_KERN_COMBI) - { - // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here - // since we still need to combine the plains - - if (line_len > data.pw_max) - { - hc_thread_mutex_lock (mux_counter); - - for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++) - { - data.words_progress_rejected[salt_pos] += data.combs_cnt; - } - - hc_thread_mutex_unlock (mux_counter); - - continue; - } - } pw_add (device_param, (u8 *) line_buf, line_len); @@ -5360,7 +5363,7 @@ static uint hlfmt_detect (FILE *fp, uint max_check) // wrapper around mymalloc for ADL #if defined(HAVE_HWMON) -void *__stdcall ADL_Main_Memory_Alloc (const int iSize) +void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize) { return mymalloc (iSize); } @@ -5382,8 +5385,6 @@ static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, cons for (uint i = 0; i < digests_cnt; i++) { - if (data.digests_shown[i] == 1) continue; // can happen with potfile - uint *digest_ptr = (uint *) digests_buf_ptr; digests_buf_ptr += dgst_size; @@ -5435,8 +5436,8 @@ void SetConsoleWindowSize (const int x) COORD co; - co.X = sr->Right + 1; - co.Y = sr->Bottom + 1; + co.X = sr->Right + 1; + co.Y = 9999; if (!SetConsoleScreenBufferSize (h, co)) return; @@ -13671,10 +13672,16 @@ int main (int argc, char **argv) { if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL) { - log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1); - log_info (" You can use --force to override this but do not post error reports if you do so"); + if (data.force == 0) + { + if (algorithm_pos == 0) + { + log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1); + log_info (" You can use --force to override this but do not post error reports if you do so"); + } - if (data.force == 0) device_param->skipped = 1; + device_param->skipped = 1; + } } } @@ -14001,9 +14008,9 @@ int main (int argc, char **argv) */ #ifdef HAVE_HWMON - hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } }; - hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } }; - hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } }; + hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } }; + hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } }; + hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } }; if (gpu_temp_disable == 0) { @@ -14032,18 +14039,18 @@ int main (int argc, char **argv) for (int i = 0; i < tmp_in; i++) { - hm_adapters_nvml[tmp_out++].adapter_index.nvml = nvmlGPUHandle[i]; + hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i]; } for (int i = 0; i < tmp_out; i++) { unsigned int speed; - if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].adapter_index.nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1; + if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1; - hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].adapter_index.nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS); + 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].adapter_index.nvml, NVML_GOM_ALL_ON); + hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON); } } } @@ -14065,7 +14072,7 @@ int main (int argc, char **argv) for (int i = 0; i < tmp_in; i++) { - hm_adapters_nvapi[tmp_out++].adapter_index.nvapi = nvGPUHandle[i]; + hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i]; } } } @@ -14250,14 +14257,24 @@ int main (int argc, char **argv) const uint platform_devices_id = device_param->platform_devices_id; - if (device_param->device_vendor_id == VENDOR_ID_NV) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - memcpy (&data.hm_device[device_id], &hm_adapters_nvml[platform_devices_id], sizeof (hm_attrs_t)); + 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].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 = hm_adapters_adl[platform_devices_id].fan_set_supported; } - if (device_param->device_vendor_id == VENDOR_ID_AMD) + if (device_param->device_vendor_id == VENDOR_ID_NV) { - memcpy (&data.hm_device[device_id], &hm_adapters_adl[platform_devices_id], sizeof (hm_attrs_t)); + 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].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; } } } @@ -14294,7 +14311,7 @@ int main (int argc, char **argv) int powertune_supported = 0; - if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK) + 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"); @@ -14309,9 +14326,9 @@ int main (int argc, char **argv) ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; - if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune)) == ADL_OK) + 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].adapter_index.adl, &od_power_control_status[device_id]); + 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) @@ -14321,7 +14338,7 @@ int main (int argc, char **argv) return (-1); } - if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, powertune.iMaxValue)) != ADL_OK) + 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"); @@ -14334,7 +14351,7 @@ int main (int argc, char **argv) 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].adapter_index.adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK) + 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"); @@ -14345,7 +14362,7 @@ int main (int argc, char **argv) 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].adapter_index.adl, &caps)) != ADL_OK) + 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"); @@ -14382,7 +14399,7 @@ int main (int argc, char **argv) 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].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + 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"); @@ -14399,14 +14416,14 @@ int main (int argc, char **argv) // 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].adapter_index.adl, &powertune)) != ADL_OK) + 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].adapter_index.adl, powertune.iMaxValue)) != ADL_OK) + 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"); @@ -14424,7 +14441,7 @@ int main (int argc, char **argv) int powertune_supported = 0; - if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &limit) == NVML_SUCCESS) + if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS) { powertune_supported = 1; } @@ -14436,11 +14453,11 @@ int main (int argc, char **argv) unsigned int minLimit; unsigned int maxLimit; - if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &minLimit, &maxLimit) == NVML_SUCCESS) + 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].adapter_index.nvml, maxLimit) == NVML_SUCCESS) + 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 @@ -14525,6 +14542,8 @@ int main (int argc, char **argv) device_param->kernel_threads = kernel_threads; + device_param->hardware_power = device_processors * kernel_threads; + /** * create input buffers on device : calculate size of fixed memory buffers */ @@ -15735,21 +15754,6 @@ int main (int argc, char **argv) #if defined(HAVE_HWMON) - /** - * Store thermal target temperature so we can send a notice to user - */ - - if (gpu_temp_disable == 0) - { - const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id); - const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id); - - data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000; - data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000; - - // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too - } - /** * Store initial fanspeed if gpu_temp_retain is enabled */ @@ -17034,7 +17038,7 @@ int main (int argc, char **argv) data.ms_paused = 0; - data.kernel_power_div = 0; + data.kernel_power_final = 0; data.words_cur = rd->words_cur; @@ -17544,35 +17548,12 @@ int main (int argc, char **argv) } } - data.devices_status = STATUS_RUNNING; - - if (initial_restore_done == 0) - { - if (data.restore_disable == 0) cycle_restore (); - - initial_restore_done = 1; - } - - hc_timer_set (&data.timer_running); - - if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) - { - if ((quiet == 0) && (status == 0) && (benchmark == 0)) - { - if (quiet == 0) fprintf (stdout, "%s", PROMPT); - if (quiet == 0) fflush (stdout); - } - } - else if (wordlist_mode == WL_MODE_STDIN) - { - if (data.quiet == 0) log_info ("Starting attack in stdin mode..."); - if (data.quiet == 0) log_info (""); - } - /** * create autotune threads */ + data.devices_status = STATUS_AUTOTUNE; + hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t)); for (uint device_id = 0; device_id < data.devices_cnt; device_id++) @@ -17588,15 +17569,21 @@ int main (int argc, char **argv) * Inform user about possible slow speeds */ + uint hardware_power_all = 0; + uint kernel_power_all = 0; for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { hc_device_param_t *device_param = &devices_param[device_id]; + hardware_power_all += device_param->hardware_power; + kernel_power_all += device_param->kernel_power; } + 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 + data.kernel_power_all = kernel_power_all; if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) @@ -17619,6 +17606,31 @@ int main (int argc, char **argv) * create cracker threads */ + data.devices_status = STATUS_RUNNING; + + if (initial_restore_done == 0) + { + if (data.restore_disable == 0) cycle_restore (); + + initial_restore_done = 1; + } + + hc_timer_set (&data.timer_running); + + if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) + { + if ((quiet == 0) && (status == 0) && (benchmark == 0)) + { + if (quiet == 0) fprintf (stdout, "%s", PROMPT); + if (quiet == 0) fflush (stdout); + } + } + else if (wordlist_mode == WL_MODE_STDIN) + { + if (data.quiet == 0) log_info ("Starting attack in stdin mode..."); + if (data.quiet == 0) log_info (""); + } + time_t runtime_start; time (&runtime_start); @@ -17995,7 +18007,7 @@ int main (int argc, char **argv) int powertune_supported = 0; - if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK) + if ((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"); @@ -18006,7 +18018,7 @@ int main (int argc, char **argv) { // powercontrol settings - if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, od_power_control_status[device_id])) != ADL_OK) + if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK) { log_info ("ERROR: Failed to restore the ADL PowerControl values"); @@ -18024,7 +18036,7 @@ int main (int argc, char **argv) performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock; performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; - if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + if ((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 restore ADL performance state"); @@ -18042,7 +18054,7 @@ int main (int argc, char **argv) if (limit > 0) { - hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, limit); + hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit); } } } @@ -18240,3 +18252,4 @@ int main (int argc, char **argv) return -1; } +