-/**
+ /**
* Authors.....: Jens Steube <jens.steube@gmail.com>
* Gabriele Gristina <matrix@hashcat.net>
* magnum <john.magnum@hushmail.com>
#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
+#define NVIDIA_100PERCENTCPU_WORKAROUND 100
+
#define global_free(attr) \
{ \
myfree ((void *) data.attr); \
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,
" 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
" 501 | Juniper IVE | Operating-Systems",
" 5800 | Android PIN | Operating-Systems",
+ " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
" 8100 | Citrix Netscaler | Operating-Systems",
" 8500 | RACF | Operating-Systems",
" 7200 | GRUB 2 | Operating-Systems",
}
#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);
hc_thread_mutex_unlock (mux_adl);
}
+
#endif // HAVE_HWMON
}
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)
+static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
{
uint num_elements = num;
hc_clFlush (data.ocl, device_param->command_queue);
+ if (data.devices_status == STATUS_RUNNING)
+ {
+ switch (kern_run)
+ {
+ case KERN_RUN_1: usleep (device_param->exec_us_prev1[iteration]); break;
+ case KERN_RUN_2: usleep (device_param->exec_us_prev2[iteration]); break;
+ case KERN_RUN_3: usleep (device_param->exec_us_prev3[iteration]); break;
+ }
+ }
+
hc_clWaitForEvents (data.ocl, 1, &event);
- if (event_update)
- {
- cl_ulong time_start;
- cl_ulong time_end;
+ cl_ulong time_start;
+ cl_ulong time_end;
- hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
- hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
+ hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
+ hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
- const double exec_time = (double) (time_end - time_start) / 1000000.0;
+ const double exec_us = (double) (time_end - time_start) / 1000;
+
+ if (data.devices_status == STATUS_RUNNING)
+ {
+ switch (kern_run)
+ {
+ case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
+ case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
+ case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
+ }
+ }
+ if (event_update)
+ {
uint exec_pos = device_param->exec_pos;
- device_param->exec_ms[exec_pos] = exec_time;
+ device_param->exec_ms[exec_pos] = exec_us / 1000;
exec_pos++;
*/
}
-static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
+static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
{
if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
if (highest_pw_len < 16)
{
- run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
+ run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
}
else if (highest_pw_len < 32)
{
- run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
+ run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
}
else
{
- run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
+ run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
}
}
else
{
run_kernel_amp (device_param, pws_cnt);
- run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
+ run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
if (opts_type & OPTS_TYPE_HOOK12)
{
- run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
+ run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
}
uint iter = salt_buf->salt_iter;
uint loop_step = device_param->kernel_loops;
- for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
+ for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
{
uint loop_left = iter - loop_pos;
device_param->kernel_params_buf32[25] = loop_pos;
device_param->kernel_params_buf32[26] = loop_left;
- run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
+ run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
if (data.devices_status == STATUS_CRACKED) break;
if (data.devices_status == STATUS_ABORTED) break;
if (opts_type & OPTS_TYPE_HOOK23)
{
- run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
+ run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
}
- run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
+ run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
}
}
if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
- run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
+ run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
}
else
{
- run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
+ run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
}
const double exec_ms_prev = get_avg_exec_time (device_param, 1);
memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
+ memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
+ memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
+ memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
+
// store
device_param->kernel_accel = kernel_accel;
// innerloops
- for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
+ for (uint innerloop_pos = 0, fast_iteration = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step, fast_iteration++)
{
while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
hc_timer_set (&device_param->timer_speed);
}
- choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
+ choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
* result
*/
- check_cracked (device_param, salt_pos);
+ if (data.benchmark == 0)
+ {
+ check_cracked (device_param, salt_pos);
+ }
/**
* progress
uint status_left = data.status_timer;
#ifdef HAVE_HWMON
- uint hwmon_check = 0;
+ uint hwmon_check = 0;
int slowdown_warnings = 0;
#ifdef HAVE_HWMON
- if (1)
+ if (hwmon_check == 1)
{
hc_thread_mutex_lock (mux_adl);
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 ();
+
+ log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
- if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
- if (data.quiet == 0) fflush (stdout);
+ if (slowdown_warnings == 2)
+ {
+ log_info ("");
+ }
- slowdown_warnings++;
+ 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);
{
if (device_param->device_vendor_id == VENDOR_ID_AMD)
{
- hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
+ hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
}
else if (device_param->device_vendor_id == VENDOR_ID_NV)
{
//}
}
-static u32 get_power (const u32 kernel_power)
+static void set_kernel_power_final (const u64 kernel_power_final)
{
- if (data.kernel_power_div)
+ if (data.quiet == 0)
{
- return (float) kernel_power * data.kernel_power_div;
+ clear_prompt ();
+
+ //log_info ("");
+
+ log_info ("INFO: approaching final keyspace, workload adjusted");
+ log_info ("");
+
+ fprintf (stdout, "%s", PROMPT);
+
+ fflush (stdout);
}
- return kernel_power;
+ data.kernel_power_final = kernel_power_final;
+}
+
+static u32 get_power (hc_device_param_t *device_param)
+{
+ const u64 kernel_power_final = data.kernel_power_final;
+
+ if (kernel_power_final)
+ {
+ 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 device_param->kernel_power;
}
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);
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);
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))
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);
if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
- run_kernel (KERN_RUN_1, device_param, 1, false);
+ run_kernel (KERN_RUN_1, device_param, 1, false, 0);
}
else
{
- run_kernel (KERN_RUN_1, device_param, 1, false);
+ run_kernel (KERN_RUN_1, device_param, 1, false, 0);
uint loop_step = 16;
device_param->kernel_params_buf32[25] = loop_pos;
device_param->kernel_params_buf32[26] = loop_left;
- run_kernel (KERN_RUN_2, device_param, 1, false);
+ run_kernel (KERN_RUN_2, device_param, 1, false, 0);
}
- run_kernel (KERN_RUN_3, device_param, 1, false);
+ run_kernel (KERN_RUN_3, device_param, 1, false, 0);
}
/**
// 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);
}
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;
* main
*/
-#ifdef _WIN
+#ifdef WIN
void SetConsoleWindowSize (const int x)
{
HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
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;
int main (int argc, char **argv)
{
- #ifdef _WIN
+ #ifdef WIN
SetConsoleWindowSize (132);
#endif
{
log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
log_info ("");
+ log_info ("Note: Reported benchmark cracking speed = real cracking speed");
+ log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
+ log_info ("");
}
else
{
return (-1);
}
- if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
+ if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
{
log_error ("ERROR: Invalid hash-type specified");
gpu_temp_disable = 1;
#ifdef HAVE_HWMON
- powertune_enable = 1;
+ if (powertune_enable == 1)
+ {
+ gpu_temp_disable = 0;
+ }
#endif
data.status_timer = status_timer;
dgst_pos3 = 3;
break;
+ case 13800: hash_type = HASH_TYPE_SHA256;
+ salt_type = SALT_TYPE_EMBEDDED;
+ attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
+ opts_type = OPTS_TYPE_PT_GENERATE_BE
+ | OPTS_TYPE_PT_UNICODE;
+ kern_type = KERN_TYPE_WIN8PHONE;
+ dgst_size = DGST_SIZE_4_8;
+ parse_func = win8phone_parse_hash;
+ sort_by_digest = sort_by_digest_4_8;
+ opti_type = OPTI_TYPE_ZERO_BYTE
+ | OPTI_TYPE_PRECOMPUTE_INIT
+ | OPTI_TYPE_EARLY_SKIP
+ | OPTI_TYPE_NOT_ITERATED
+ | OPTI_TYPE_RAW_HASH;
+ dgst_pos0 = 3;
+ dgst_pos1 = 7;
+ dgst_pos2 = 2;
+ dgst_pos3 = 6;
+ break;
+
default: usage_mini_print (PROGNAME); return (-1);
}
case 13761: esalt_size = sizeof (tc_t); break;
case 13762: esalt_size = sizeof (tc_t); break;
case 13763: esalt_size = sizeof (tc_t); break;
+ case 13800: esalt_size = sizeof (win8phone_t); break;
}
data.esalt_size = esalt_size;
break;
case 7400: if (pw_max > 16) pw_max = 16;
break;
- case 7500: if (pw_max > 8) pw_max = 8;
+ case 7700: if (pw_max > 8) pw_max = 8;
break;
case 7900: if (pw_max > 48) pw_max = 48;
break;
* OpenCL devices: simply push all devices from all platforms into the same device array
*/
- int need_adl = 0;
- int need_nvml = 0;
+ int need_adl = 0;
+ int need_nvapi = 0;
+ int need_nvml = 0;
hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
if (device_endian_little == CL_FALSE)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
+ log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
device_param->skipped = 1;
}
if (device_available == CL_FALSE)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
+ log_info ("Device #%u: WARNING: device not available", device_id + 1);
device_param->skipped = 1;
}
if (device_compiler_available == CL_FALSE)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
+ log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
device_param->skipped = 1;
}
if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
+ log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
device_param->skipped = 1;
}
if (strstr (device_extensions, "base_atomics") == 0)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
+ log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
device_param->skipped = 1;
}
if (strstr (device_extensions, "byte_addressable_store") == 0)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
+ log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
device_param->skipped = 1;
}
if (device_local_mem_size < 32768)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
+ log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
device_param->skipped = 1;
}
{
if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
+ 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");
+ }
- device_param->skipped = 1;
+ device_param->skipped = 1;
+ }
}
}
if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
{
need_nvml = 1;
+
+ #ifdef _WIN
+ need_nvapi = 1;
+ #endif
}
}
*/
#ifdef HAVE_HWMON
- hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
- hm_attrs_t hm_adapters_amd[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)
{
- NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
- ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
+ 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));
- data.hm_amd = NULL;
- data.hm_nv = NULL;
+ data.hm_adl = NULL;
+ data.hm_nvapi = NULL;
+ data.hm_nvml = NULL;
if ((need_nvml == 1) && (nvml_init (nvml) == 0))
{
- data.hm_nv = nvml;
+ data.hm_nvml = nvml;
}
- if (data.hm_nv)
+ if (data.hm_nvml)
{
- if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
+ if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
{
- HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
+ HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
- int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
+ int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
int tmp_out = 0;
for (int i = 0; i < tmp_in; i++)
{
- hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[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_nv, 0, hm_adapters_nv[i].adapter_index.nv, &speed) == NVML_SUCCESS) hm_adapters_nv[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].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
+
+ hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
+ }
+ }
+ }
+
+ if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
+ {
+ data.hm_nvapi = nvapi;
+ }
- hm_NVML_nvmlDeviceSetComputeMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
+ if (data.hm_nvapi)
+ {
+ if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
+ {
+ HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
+
+ int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
+
+ int tmp_out = 0;
- hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_GOM_ALL_ON);
+ for (int i = 0; i < tmp_in; i++)
+ {
+ hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
}
}
}
if ((need_adl == 1) && (adl_init (adl) == 0))
{
- data.hm_amd = adl;
+ data.hm_adl = adl;
}
- if (data.hm_amd)
+ if (data.hm_adl)
{
- if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
+ if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
{
// total number of adapters
int hm_adapters_num;
- if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
+ if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
// adapter info
- LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
+ LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
if (lpAdapterInfo == NULL) return (-1);
{
hc_thread_mutex_lock (mux_adl);
- // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
+ // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
- hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
+ hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
- hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
- hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, 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_adl);
}
}
}
- if (data.hm_amd == NULL && data.hm_nv == NULL)
+ if (data.hm_adl == NULL && data.hm_nvml == NULL)
{
gpu_temp_disable = 1;
}
*/
#ifdef HAVE_HWMON
- if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
+ if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
{
log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
}
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_nv[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_amd[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;
}
}
}
int powertune_supported = 0;
- if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &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");
ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
- if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &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_amd, data.hm_device[device_id].adapter_index.amd, &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)
return (-1);
}
- if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 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");
od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
- if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 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");
ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
- if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &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");
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_amd, data.hm_device[device_id].adapter_index.amd, 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");
// powertune set
ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
- if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &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_amd, data.hm_device[device_id].adapter_index.amd, 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");
int powertune_supported = 0;
- if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &limit) == NVML_SUCCESS)
+ if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
{
powertune_supported = 1;
}
unsigned int minLimit;
unsigned int maxLimit;
- if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &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_nv, 0, data.hm_device[device_id].adapter_index.nv, 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
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
*/
* some algorithms need a fixed kernel-loops count
*/
- if (hash_mode == 1500)
+ if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
{
const u32 kernel_loops_fixed = 1024;
device_param->kernel_loops_max = kernel_loops_fixed;
}
- if (hash_mode == 3000)
+ if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
{
const u32 kernel_loops_fixed = 1024;
#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
*/
if (device_param->device_vendor_id == VENDOR_ID_AMD)
{
- rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
+ rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
}
else if (device_param->device_vendor_id == VENDOR_ID_NV)
{
data.ms_paused = 0;
- data.kernel_power_div = 0;
+ data.kernel_power_final = 0;
data.words_cur = rd->words_cur;
}
}
- 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++)
* 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))
* 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);
if (device_param->device_vendor_id == VENDOR_ID_AMD)
{
- rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
+ rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
}
else if (device_param->device_vendor_id == VENDOR_ID_NV)
{
int powertune_supported = 0;
- if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &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");
{
// powercontrol settings
- if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, 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");
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_amd, data.hm_device[device_id].adapter_index.amd, 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");
if (limit > 0)
{
- hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, limit);
+ hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
}
}
}
if (gpu_temp_disable == 0)
{
- if (data.hm_nv)
+ if (data.hm_nvml)
{
- hm_NVML_nvmlShutdown (data.hm_nv);
+ hm_NVML_nvmlShutdown (data.hm_nvml);
- nvml_close (data.hm_nv);
+ nvml_close (data.hm_nvml);
- data.hm_nv = NULL;
+ data.hm_nvml = NULL;
}
- if (data.hm_amd)
+ if (data.hm_adl)
{
- hm_ADL_Main_Control_Destroy (data.hm_amd);
+ hm_ADL_Main_Control_Destroy (data.hm_adl);
- adl_close (data.hm_amd);
+ adl_close (data.hm_adl);
- data.hm_amd = NULL;
+ data.hm_adl = NULL;
}
}
#endif // HAVE_HWMON