arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2024-11-22 08:08:10 +00:00
Code Issues Releases Wiki Activity

fixed bug in benchmark engine, updated negative status code

Browse Source
This commit is contained in:
Gabriele Gristina 2022-01-11 04:58:30 +01:00
parent e18d16bc6e
commit 7650894e02
11 changed files with 126 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/changes.txt
View File

@ -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

6
docs/status_codes.txt
View File

@ -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

11
include/types.h
View File

@ -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;

1
src/autotune.c
View File

@ -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)

77
src/backend.c
View File

@ -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;

4
src/dispatch.c
View File

@ -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)

45
src/hashcat.c
View File

@ -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

2
src/monitor.c
View File

@ -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++;

1
src/selftest.c
View File

@ -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)

11
src/status.c
View File

@ -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;

19
src/terminal.c
View File

@ -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,