From 7650894e02253d4e94abf8d230bdab802c736163 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Tue, 11 Jan 2022 04:58:30 +0100 Subject: [PATCH] fixed bug in benchmark engine, updated negative status code --- docs/changes.txt | 2 ++ docs/status_codes.txt | 6 ++++ include/types.h | 11 +++++++ src/autotune.c | 1 - src/backend.c | 77 ++++++++++++++++++++++++++++++++++--------- src/dispatch.c | 4 --- src/hashcat.c | 45 ++++++++++++++++++++++++- src/monitor.c | 2 -- src/selftest.c | 1 - src/status.c | 11 ++----- src/terminal.c | 19 ----------- 11 files changed, 126 insertions(+), 53 deletions(-) diff --git a/docs/changes.txt b/docs/changes.txt index f99eb33dd..514ce1ca9 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -26,6 +26,7 @@ - Fixed undefined function call to hc_byte_perm_S() in hash-mode 17010 on non-CUDA compute devices - Fixed wordlist handling in -m 3000 when candidate passwords use the $HEX[...] syntax - Fixed false negative on Unit Test with hash-type 25400 +- Fixed bug on benchmark engine, from now it will not stop at the first error detected ## ## Technical @@ -45,6 +46,7 @@ - HIP Backend: moved functions to ext_hip.c/ext_hiprtc.c and includes to ext_hip.h/ext_hiprtc.h - CUDA Backend: moved functions to ext_cuda.c/ext_nvrtc.c and includes to ext_cuda.h/ext_nvrtc.h - Makefile: updated MACOSX_DEPLOYMENT_TARGET to 10.15 and removed OpenCL framework from LFLAGS_NATIVE on MacOS +- Status code: updated negative status code, usefull in Unit tests engine (test.sh) * changes v6.2.4 -> v6.2.5 diff --git a/docs/status_codes.txt b/docs/status_codes.txt index 0c8c831b4..b7889ff2e 100644 --- a/docs/status_codes.txt +++ b/docs/status_codes.txt @@ -1,6 +1,12 @@ status codes on exit: ===================== +-8 = mixed backend errors (combo of -3, -4, -5, -6, -7 errors type) +-7 = backend error: Invalid module_extra_buffer_size +-6 = backend error: Too many compute units to keep minimum kernel accel limit +-5 = backend error: main kernel build error +-4 = backend error: memory hit +-3 = backend error: skipping hash-type due to module_unstable_warning settings -2 = gpu-watchdog alarm -1 = error 0 = OK/cracked diff --git a/include/types.h b/include/types.h index fa3e2de6c..d665dd8ad 100644 --- a/include/types.h +++ b/include/types.h @@ -1683,6 +1683,17 @@ typedef struct backend_ctx { bool enabled; + // global rc + + bool memory_hit_warning; + bool runtime_skip_warning; + bool kernel_build_warning; + bool kernel_accel_warnings; + bool extra_size_warning; + bool mixed_warnings; + + // generic + void *cuda; void *hip; void *ocl; diff --git a/src/autotune.c b/src/autotune.c index b5a66f75f..c89373126 100644 --- a/src/autotune.c +++ b/src/autotune.c @@ -525,7 +525,6 @@ HC_API_CALL void *thread_autotune (void *p) hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid; if (device_param->skipped == true) return NULL; - if (device_param->skipped_warning == true) return NULL; if (device_param->is_cuda == true) diff --git a/src/backend.c b/src/backend.c index 63fbba09b..53a2fb819 100644 --- a/src/backend.c +++ b/src/backend.c @@ -112,7 +112,6 @@ static int backend_ctx_find_alias_devices (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *backend_device = &backend_ctx->devices_param[backend_devices_pos]; if (backend_device->skipped == true) continue; - if (backend_device->skipped_warning == true) continue; for (int device_id_alias_pos = 0; device_id_alias_pos < backend_device->device_id_alias_cnt; device_id_alias_pos++) @@ -122,7 +121,6 @@ static int backend_ctx_find_alias_devices (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *alias_device = &backend_ctx->devices_param[alias_pos]; if (alias_device->skipped == true) continue; - if (alias_device->skipped_warning == true) continue; // this lets CUDA devices survive over OpenCL @@ -6433,7 +6431,6 @@ void backend_ctx_devices_sync_tuning (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param_src = &backend_ctx->devices_param[backend_devices_cnt_src]; if (device_param_src->skipped == true) continue; - if (device_param_src->skipped_warning == true) continue; for (int backend_devices_cnt_dst = backend_devices_cnt_src + 1; backend_devices_cnt_dst < backend_ctx->backend_devices_cnt; backend_devices_cnt_dst++) @@ -6441,7 +6438,6 @@ void backend_ctx_devices_sync_tuning (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param_dst = &backend_ctx->devices_param[backend_devices_cnt_dst]; if (device_param_dst->skipped == true) continue; - if (device_param_dst->skipped_warning == true) continue; if (is_same_device_type (device_param_src, device_param_dst) == false) continue; @@ -6477,7 +6473,6 @@ void backend_ctx_devices_update_power (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; kernel_power_all += device_param->kernel_power; @@ -6525,7 +6520,6 @@ void backend_ctx_devices_kernel_loops (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; device_param->kernel_loops_min = device_param->kernel_loops_min_sav; @@ -7321,6 +7315,19 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) u32 hardware_power_all = 0; + int backend_memory_hit_warnings = 0; + int backend_runtime_skip_warnings = 0; + int backend_kernel_build_warnings = 0; + int backend_kernel_accel_warnings = 0; + int backend_extra_size_warning = 0; + + backend_ctx->memory_hit_warning = false; + backend_ctx->runtime_skip_warning = false; + backend_ctx->kernel_build_warning = false; + backend_ctx->kernel_accel_warnings = false; + backend_ctx->extra_size_warning = false; + backend_ctx->mixed_warnings = false; + for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { /** @@ -7351,8 +7358,9 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) event_log_warning (hashcat_ctx, " This is due to a known CUDA/HIP/OpenCL runtime/driver issue (not a hashcat issue)"); event_log_warning (hashcat_ctx, " You can use --force to override, but do not report related errors."); - device_param->skipped_warning = true; + backend_runtime_skip_warnings++; + device_param->skipped_warning = true; continue; } } @@ -7940,7 +7948,9 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) { event_log_error (hashcat_ctx, "Invalid extra buffer size."); - device_param->skipped = true; + backend_extra_size_warning++; + + device_param->skipped_warning = true; continue; } @@ -8475,7 +8485,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) { event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed.", device_param->device_id + 1, source_file); - return -1; + backend_kernel_build_warnings++; + + device_param->skipped_warning = true; + continue; } hcfree (build_options_module_buf); @@ -8636,7 +8649,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) { event_log_error (hashcat_ctx, "* Device #%u: Not enough allocatable device memory for this hashlist/ruleset.", device_id + 1); - return -1; + backend_memory_hit_warnings++; + + device_param->skipped_warning = true; + continue; } if (device_param->is_cuda == true) @@ -11226,7 +11242,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) event_log_error (hashcat_ctx, "* Device #%u: Too many compute units to keep minimum kernel accel limit.", device_id + 1); event_log_error (hashcat_ctx, " Retry with lower --backend-kernel-threads value."); - return -1; + backend_kernel_accel_warnings++; + + device_param->skipped_warning = true; + continue; } // Opposite direction check: find out if we would request too much memory on memory blocks which are based on kernel_accel @@ -11411,7 +11430,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) { event_log_error (hashcat_ctx, "* Device #%u: Not enough allocatable device memory for this attack.", device_id + 1); - return -1; + backend_memory_hit_warnings++; + + device_param->skipped_warning = true; + continue; } // similar process for association attack @@ -11740,6 +11762,32 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) EVENT_DATA (EVENT_BACKEND_DEVICE_INIT_POST, &backend_devices_idx, sizeof (int)); } + int rc = 0; + + backend_ctx->memory_hit_warning = (backend_memory_hit_warnings == backend_ctx->backend_devices_active); + backend_ctx->runtime_skip_warning = (backend_runtime_skip_warnings == backend_ctx->backend_devices_active); + backend_ctx->kernel_build_warning = (backend_kernel_build_warnings == backend_ctx->backend_devices_active); + backend_ctx->kernel_accel_warnings = (backend_kernel_accel_warnings == backend_ctx->backend_devices_active); + backend_ctx->extra_size_warning = (backend_extra_size_warning == backend_ctx->backend_devices_active); + + // if all active devices failed, set rc to -1 + // later we prevent hashcat exit if is started in benchmark mode + if ((backend_ctx->memory_hit_warning == true) || + (backend_ctx->runtime_skip_warning == true) || + (backend_ctx->kernel_build_warning == true) || + (backend_ctx->kernel_accel_warnings == true) || + (backend_ctx->extra_size_warning == true)) + { + rc = -1; + } + else + { + // handle mix of, in case of multiple devices with different warnings + backend_ctx->mixed_warnings = ((backend_memory_hit_warnings + backend_runtime_skip_warnings + backend_kernel_build_warnings + backend_kernel_accel_warnings + backend_extra_size_warning) == backend_ctx->backend_devices_active); + + if (backend_ctx->mixed_warnings) rc = -1; + } + if (user_options->benchmark == false) { if (hardware_power_all == 0) return -1; @@ -11749,7 +11797,7 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx) EVENT_DATA (EVENT_BACKEND_SESSION_HOSTMEM, &size_total_host_all, sizeof (u64)); - return 0; + return rc; } void backend_session_destroy (hashcat_ctx_t *hashcat_ctx) @@ -12264,7 +12312,6 @@ int backend_session_update_combinator (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; // kernel_params @@ -12310,7 +12357,6 @@ int backend_session_update_mp (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; device_param->kernel_params_mp_buf64[3] = 0; @@ -12355,7 +12401,6 @@ int backend_session_update_mp_rl (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_ hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; device_param->kernel_params_mp_l_buf64[3] = 0; diff --git a/src/dispatch.c b/src/dispatch.c index 2078cfdac..d8870d033 100644 --- a/src/dispatch.c +++ b/src/dispatch.c @@ -32,7 +32,6 @@ static u64 get_highest_words_done (const hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; const u64 words_done = device_param->words_done; @@ -54,7 +53,6 @@ static u64 get_lowest_words_done (const hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; const u64 words_done = device_param->words_done; @@ -353,7 +351,6 @@ HC_API_CALL void *thread_calc_stdin (void *p) hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid; if (device_param->skipped) return NULL; - if (device_param->skipped_warning == true) return NULL; if (device_param->is_cuda == true) @@ -1605,7 +1602,6 @@ HC_API_CALL void *thread_calc (void *p) hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid; if (device_param->skipped) return NULL; - if (device_param->skipped_warning == true) return NULL; if (device_param->is_cuda == true) diff --git a/src/hashcat.c b/src/hashcat.c index bf936ccc0..91a25f2cf 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -767,7 +767,38 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx) EVENT (EVENT_BACKEND_SESSION_PRE); - if (backend_session_begin (hashcat_ctx) == -1) return -1; + if (backend_session_begin (hashcat_ctx) == -1) + { + if (user_options->benchmark == true) + { + if (user_options->hash_mode_chgd == false) + { + // finalize backend session + + backend_session_destroy (hashcat_ctx); + + // clean up + + #ifdef WITH_BRAIN + brain_ctx_destroy (hashcat_ctx); + #endif + + bitmap_ctx_destroy (hashcat_ctx); + combinator_ctx_destroy (hashcat_ctx); + cpt_ctx_destroy (hashcat_ctx); + hashconfig_destroy (hashcat_ctx); + hashes_destroy (hashcat_ctx); + mask_ctx_destroy (hashcat_ctx); + status_progress_destroy (hashcat_ctx); + straight_ctx_destroy (hashcat_ctx); + wl_data_destroy (hashcat_ctx); + + return 0; + } + } + + return -1; + } EVENT (EVENT_BACKEND_SESSION_POST); @@ -1500,6 +1531,7 @@ int hashcat_session_execute (hashcat_ctx_t *hashcat_ctx) logfile_ctx_t *logfile_ctx = hashcat_ctx->logfile_ctx; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; user_options_t *user_options = hashcat_ctx->user_options; + backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx; // start logfile entry @@ -1712,6 +1744,17 @@ int hashcat_session_execute (hashcat_ctx_t *hashcat_ctx) if (status_ctx->devices_status == STATUS_CRACKED) rc_final = 0; if (status_ctx->devices_status == STATUS_ERROR) rc_final = -1; } + else if (rc_final == -1) + { + // setup the new negative status code, usefull in test.sh + // -2 is marked as used in status_codes.txt + if (backend_ctx->runtime_skip_warning == true) rc_final = -3; + if (backend_ctx->memory_hit_warning == true) rc_final = -4; + if (backend_ctx->kernel_build_warning == true) rc_final = -5; + if (backend_ctx->kernel_accel_warnings == true) rc_final = -6; + if (backend_ctx->extra_size_warning == true) rc_final = -7; + if (backend_ctx->mixed_warnings == true) rc_final = -8; + } // special case for --stdout diff --git a/src/monitor.c b/src/monitor.c index b61a41824..ce02a7a90 100644 --- a/src/monitor.c +++ b/src/monitor.c @@ -151,7 +151,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; const int rc_throttle = hm_get_throttle_with_devices_idx (hashcat_ctx, backend_devices_idx); @@ -261,7 +260,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx) hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) continue; - if (device_param->skipped_warning == true) continue; exec_cnt++; diff --git a/src/selftest.c b/src/selftest.c index 5379650aa..28b7b6d4f 100644 --- a/src/selftest.c +++ b/src/selftest.c @@ -900,7 +900,6 @@ HC_API_CALL void *thread_selftest (void *p) hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid; if (device_param->skipped == true) return NULL; - if (device_param->skipped_warning == true) return NULL; if (device_param->is_cuda == true) diff --git a/src/status.c b/src/status.c index 8bf13d4b3..ed7d0ba9a 100644 --- a/src/status.c +++ b/src/status.c @@ -1885,6 +1885,7 @@ char *status_get_brain_rx_all (const hashcat_ctx_t *hashcat_ctx) for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; + if ((device_param->skipped == false) && (device_param->skipped_warning == false)) { brain_rx_all += device_param->brain_link_recv_bytes; @@ -1927,6 +1928,7 @@ char *status_get_brain_tx_all (const hashcat_ctx_t *hashcat_ctx) for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++) { hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; + if ((device_param->skipped == false) && (device_param->skipped_warning == false)) { brain_tx_all += device_param->brain_link_send_bytes; @@ -2024,7 +2026,6 @@ char *status_get_hwmon_dev (const hashcat_ctx_t *hashcat_ctx, const int backend_ snprintf (output_buf, HCBUFSIZ_TINY, "N/A"); if (device_param->skipped == true) return output_buf; - if (device_param->skipped_warning == true) return output_buf; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; @@ -2093,7 +2094,6 @@ int status_get_corespeed_dev (const hashcat_ctx_t *hashcat_ctx, const int backen hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return -1; - if (device_param->skipped_warning == true) return -1; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; @@ -2114,7 +2114,6 @@ int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int back hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return -1; - if (device_param->skipped_warning == true) return -1; status_ctx_t *status_ctx = hashcat_ctx->status_ctx; @@ -2135,7 +2134,6 @@ u64 status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int backend hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; return device_param->outerloop_left; @@ -2148,7 +2146,6 @@ double status_get_runtime_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; return device_param->outerloop_msec; @@ -2161,7 +2158,6 @@ int status_get_kernel_accel_dev (const hashcat_ctx_t *hashcat_ctx, const int bac hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; if (device_param->kernel_accel_prev) return device_param->kernel_accel_prev; @@ -2176,7 +2172,6 @@ int status_get_kernel_loops_dev (const hashcat_ctx_t *hashcat_ctx, const int bac hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; if (device_param->kernel_loops_prev) return device_param->kernel_loops_prev; @@ -2191,7 +2186,6 @@ int status_get_kernel_threads_dev (const hashcat_ctx_t *hashcat_ctx, const int b hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; if (device_param->kernel_threads_prev) return device_param->kernel_threads_prev; @@ -2206,7 +2200,6 @@ int status_get_vector_width_dev (const hashcat_ctx_t *hashcat_ctx, const int bac hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx]; if (device_param->skipped == true) return 0; - if (device_param->skipped_warning == true) return 0; return device_param->vector_width; diff --git a/src/terminal.c b/src/terminal.c index 81381b2dc..2660b72ba 100644 --- a/src/terminal.c +++ b/src/terminal.c @@ -1175,7 +1175,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; printf ("%" PRIu64 "\t", (u64) (device_info->hashes_msec_dev * 1000)); @@ -1191,7 +1190,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; printf ("%f\t", device_info->exec_msec_dev); @@ -1214,7 +1212,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; const int temp = hm_get_temperature_with_devices_idx (hashcat_ctx, device_id); @@ -1232,7 +1229,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; // ok, little cheat here again... @@ -1351,7 +1347,6 @@ void status_display_status_json (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_num != 0) @@ -1784,7 +1779,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, @@ -1901,7 +1895,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_info->brain_link_status_dev == BRAIN_LINK_STATUS_CONNECTED) @@ -1978,7 +1971,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, @@ -2005,7 +1997,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_info->guess_candidates_dev == NULL) continue; @@ -2026,7 +2017,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_info->hwmon_dev == NULL) continue; @@ -2070,7 +2060,6 @@ void status_benchmark_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, "%d:%u:%d:%d:%.2f:%" PRIu64, device_id + 1, hash_mode, device_info->corespeed_dev, device_info->memoryspeed_dev, device_info->exec_msec_dev, (u64) (device_info->hashes_msec_dev_benchmark * 1000)); @@ -2106,7 +2095,6 @@ void status_benchmark (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, @@ -2147,7 +2135,6 @@ void status_speed_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, "%d:%" PRIu64, device_id + 1, (u64) (device_info->hashes_msec_dev_benchmark * 1000)); @@ -2178,7 +2165,6 @@ void status_speed_json (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_num != 0) @@ -2230,7 +2216,6 @@ void status_speed (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, @@ -2267,7 +2252,6 @@ void status_progress_machine_readable (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, "%d:%" PRIu64 ":%0.2f", device_id + 1, device_info->progress_dev, device_info->runtime_msec_dev); @@ -2298,7 +2282,6 @@ void status_progress_json (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; if (device_num != 0) @@ -2351,7 +2334,6 @@ void status_progress (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx, @@ -2364,7 +2346,6 @@ void status_progress (hashcat_ctx_t *hashcat_ctx) const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; - if (device_info->skipped_warning_dev == true) continue; event_log_info (hashcat_ctx,