From 5633d6808f349136d392036ae5f1b2685a195b8a Mon Sep 17 00:00:00 2001 From: jsteube Date: Fri, 4 Jan 2019 11:23:48 +0100 Subject: [PATCH] Move hash_mode specific code which enforce the use of the JiT compiler to modules --- include/modules.h | 3 + include/types.h | 12 +- modules/module_01000.c | 2 + src/interface_migrate.c | 342 ++++++++++++++++++++++++++++++++++++++++ src/opencl.c | 250 +++++------------------------ 5 files changed, 397 insertions(+), 212 deletions(-) diff --git a/include/modules.h b/include/modules.h index bb0d68d01..f7f9501e0 100644 --- a/include/modules.h +++ b/include/modules.h @@ -49,6 +49,9 @@ int module_hash_decode_zero_hash (MAYBE_UNUSED const hashconfig_t *ha int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, const char *line_buf, MAYBE_UNUSED const int line_len); int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, char *line_buf, MAYBE_UNUSED const int line_size); +u64 module_extra_buffer_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param); +char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param); + void module_hook12 (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u64 pws_cnt); void module_hook23 (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u64 pws_cnt); diff --git a/include/types.h b/include/types.h index da4a90a79..d8feba8c5 100644 --- a/include/types.h +++ b/include/types.h @@ -964,6 +964,7 @@ struct hashconfig bool outfile_check_nocomp; bool potfile_disable; bool potfile_keep_all_hashes; + bool forced_jit_compile; u32 pwdump_column; }; @@ -1315,10 +1316,10 @@ typedef struct hc_device_param cl_mem d_tmps; cl_mem d_hooks; cl_mem d_result; - cl_mem d_scryptV0_buf; - cl_mem d_scryptV1_buf; - cl_mem d_scryptV2_buf; - cl_mem d_scryptV3_buf; + cl_mem d_extra0_buf; + cl_mem d_extra1_buf; + cl_mem d_extra2_buf; + cl_mem d_extra3_buf; cl_mem d_root_css_buf; cl_mem d_markov_css_buf; cl_mem d_st_digests_buf; @@ -2285,6 +2286,9 @@ typedef struct module_ctx int (*module_hash_decode) (const hashconfig_t *, void *, salt_t *, void *, const char *, const int); int (*module_hash_encode) (const hashconfig_t *, const void *, const salt_t *, const void *, char *, int); + u64 (*module_extra_buffer_size) (const hashconfig_t *, const user_options_t *, const user_options_extra_t *, const hashes_t *, const hc_device_param_t *); + char *(*module_jit_build_options) (const hashconfig_t *, const user_options_t *, const user_options_extra_t *, const hashes_t *, const hc_device_param_t *); + void (*module_hook12) (hc_device_param_t *, const void *, const u32, const u64); void (*module_hook23) (hc_device_param_t *, const void *, const u32, const u64); diff --git a/modules/module_01000.c b/modules/module_01000.c index 99e248e4a..d3bba90fd 100644 --- a/modules/module_01000.c +++ b/modules/module_01000.c @@ -128,6 +128,7 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_dgst_size = module_dgst_size; module_ctx->module_dictstat_disable = NULL; module_ctx->module_esalt_size = NULL; + module_ctx->module_extra_buffer_size = NULL; module_ctx->module_forced_kernel_loops = NULL; module_ctx->module_forced_kernel_threads = NULL; module_ctx->module_forced_outfile_format = NULL; @@ -143,6 +144,7 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_hook23 = NULL; module_ctx->module_hook_salt_size = NULL; module_ctx->module_hook_size = NULL; + module_ctx->module_jit_build_options = NULL; module_ctx->module_kern_type = module_kern_type; module_ctx->module_opti_type = module_opti_type; module_ctx->module_opts_type = module_opts_type; diff --git a/src/interface_migrate.c b/src/interface_migrate.c index 576628fed..e1cf49080 100644 --- a/src/interface_migrate.c +++ b/src/interface_migrate.c @@ -28549,3 +28549,345 @@ int build_plain_postprocess (const u32 *src_buf, MAYBE_UNUSED const size_t src_s } } + +u64 module_size_extra_buffer (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param); +{ + + // scryptV stuff + + u64 scrypt_tmp_size = 0; + u64 scrypt_tmto_final = 0; + + u64 size_scrypt = 4; + + if ((hashconfig->hash_mode == 8900) || (hashconfig->hash_mode == 9300) || (hashconfig->hash_mode == 15700)) + { + // we need to check that all hashes have the same scrypt settings + + const u32 scrypt_N = hashes->salts_buf[0].scrypt_N; + const u32 scrypt_r = hashes->salts_buf[0].scrypt_r; + const u32 scrypt_p = hashes->salts_buf[0].scrypt_p; + + for (u32 i = 1; i < hashes->salts_cnt; i++) + { + if ((hashes->salts_buf[i].scrypt_N != scrypt_N) + || (hashes->salts_buf[i].scrypt_r != scrypt_r) + || (hashes->salts_buf[i].scrypt_p != scrypt_p)) + { + event_log_error (hashcat_ctx, "Mixed scrypt settings are not supported."); + + return -1; + } + } + + scrypt_tmp_size = (128 * scrypt_r * scrypt_p); + + hashconfig->tmp_size = scrypt_tmp_size; + + u32 tmto_start = 1; + u32 tmto_stop = 6; + + if (user_options->scrypt_tmto) + { + tmto_start = user_options->scrypt_tmto; + tmto_stop = user_options->scrypt_tmto; + } + + const u32 scrypt_threads = hashconfig->forced_kernel_threads; + + const u64 kernel_power_max = SCRYPT_MAX_ACCEL * device_processors * scrypt_threads; + + // size_pws + + const u64 size_pws = kernel_power_max * sizeof (pw_t); + + const u64 size_pws_amp = size_pws; + + // size_pws_comp + + const u64 size_pws_comp = kernel_power_max * (sizeof (u32) * 64); + + // size_pws_idx + + const u64 size_pws_idx = (kernel_power_max + 1) * sizeof (pw_idx_t); + + // size_tmps + + const u64 size_tmps = kernel_power_max * hashconfig->tmp_size; + + // size_hooks + + const u64 size_hooks = kernel_power_max * hashconfig->hook_size; + + const u64 scrypt_extra_space + = bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + size_bfs + + size_combs + + size_digests + + size_esalts + + size_hooks + + size_markov_css + + size_plains + + size_pws + + size_pws_amp + + size_pws_comp + + size_pws_idx + + size_results + + size_root_css + + size_rules + + size_rules_c + + size_salts + + size_shown + + size_tm + + size_tmps + + size_st_digests + + size_st_salts + + size_st_esalts; + + bool not_enough_memory = true; + + u32 tmto; + + for (tmto = tmto_start; tmto <= tmto_stop; tmto++) + { + size_scrypt = (128 * scrypt_r) * scrypt_N; + + size_scrypt /= 1u << tmto; + + size_scrypt *= kernel_power_max; + + if ((size_scrypt / 4) > device_param->device_maxmem_alloc) + { + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing single-block device memory allocatable for --scrypt-tmto %u.", tmto); + + continue; + } + + if ((size_scrypt + scrypt_extra_space) > device_param->device_available_mem) + { + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing total device memory allocatable for --scrypt-tmto %u.", tmto); + + continue; + } + + for (u32 salts_pos = 0; salts_pos < hashes->salts_cnt; salts_pos++) + { + scrypt_tmto_final = tmto; + } + + not_enough_memory = false; + + break; + } + + if (not_enough_memory == true) + { + event_log_error (hashcat_ctx, "Cannot allocate enough device memory. Perhaps retry with -n 1."); + + return -1; + } + + #if defined (DEBUG) + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "SCRYPT tmto optimizer value set to: %lu, mem: %lu", scrypt_tmto_final, size_scrypt); + if (user_options->quiet == false) event_log_warning (hashcat_ctx, NULL); + #endif + } + + u64 size_scrypt4 = size_scrypt / 4; + + return size_scrypt4; +} + + +char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param); +{ + /** + * Some algorithm, like descrypt, can benefit from JIT compilation + */ + + + if (hashconfig->hash_mode == 8900) + { + opencl_ctx->force_jit_compilation = 8900; + } + else if (hashconfig->hash_mode == 9300) + { + opencl_ctx->force_jit_compilation = 8900; + } + else if (hashconfig->hash_mode == 15700) + { + opencl_ctx->force_jit_compilation = 15700; + } + else if (hashconfig->hash_mode == 1500 && user_options->attack_mode == ATTACK_MODE_BF && hashes->salts_cnt == 1 && user_options->slow_candidates == false) + { + opencl_ctx->force_jit_compilation = 1500; + } + + // scryptV stuff + + u64 scrypt_tmp_size = 0; + u64 scrypt_tmto_final = 0; + + u64 size_scrypt = 4; + + if ((hashconfig->hash_mode == 8900) || (hashconfig->hash_mode == 9300) || (hashconfig->hash_mode == 15700)) + { + // we need to check that all hashes have the same scrypt settings + + const u32 scrypt_N = hashes->salts_buf[0].scrypt_N; + const u32 scrypt_r = hashes->salts_buf[0].scrypt_r; + const u32 scrypt_p = hashes->salts_buf[0].scrypt_p; + + for (u32 i = 1; i < hashes->salts_cnt; i++) + { + if ((hashes->salts_buf[i].scrypt_N != scrypt_N) + || (hashes->salts_buf[i].scrypt_r != scrypt_r) + || (hashes->salts_buf[i].scrypt_p != scrypt_p)) + { + event_log_error (hashcat_ctx, "Mixed scrypt settings are not supported."); + + return -1; + } + } + + scrypt_tmp_size = (128 * scrypt_r * scrypt_p); + + hashconfig->tmp_size = scrypt_tmp_size; + + u32 tmto_start = 1; + u32 tmto_stop = 6; + + if (user_options->scrypt_tmto) + { + tmto_start = user_options->scrypt_tmto; + tmto_stop = user_options->scrypt_tmto; + } + + const u32 scrypt_threads = hashconfig->forced_kernel_threads; + + const u64 kernel_power_max = SCRYPT_MAX_ACCEL * device_processors * scrypt_threads; + + // size_pws + + const u64 size_pws = kernel_power_max * sizeof (pw_t); + + const u64 size_pws_amp = size_pws; + + // size_pws_comp + + const u64 size_pws_comp = kernel_power_max * (sizeof (u32) * 64); + + // size_pws_idx + + const u64 size_pws_idx = (kernel_power_max + 1) * sizeof (pw_idx_t); + + // size_tmps + + const u64 size_tmps = kernel_power_max * hashconfig->tmp_size; + + // size_hooks + + const u64 size_hooks = kernel_power_max * hashconfig->hook_size; + + const u64 scrypt_extra_space + = bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + bitmap_ctx->bitmap_size + + size_bfs + + size_combs + + size_digests + + size_esalts + + size_hooks + + size_markov_css + + size_plains + + size_pws + + size_pws_amp + + size_pws_comp + + size_pws_idx + + size_results + + size_root_css + + size_rules + + size_rules_c + + size_salts + + size_shown + + size_tm + + size_tmps + + size_st_digests + + size_st_salts + + size_st_esalts; + + bool not_enough_memory = true; + + u32 tmto; + + for (tmto = tmto_start; tmto <= tmto_stop; tmto++) + { + size_scrypt = (128 * scrypt_r) * scrypt_N; + + size_scrypt /= 1u << tmto; + + size_scrypt *= kernel_power_max; + + if ((size_scrypt / 4) > device_param->device_maxmem_alloc) + { + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing single-block device memory allocatable for --scrypt-tmto %u.", tmto); + + continue; + } + + if ((size_scrypt + scrypt_extra_space) > device_param->device_available_mem) + { + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing total device memory allocatable for --scrypt-tmto %u.", tmto); + + continue; + } + + for (u32 salts_pos = 0; salts_pos < hashes->salts_cnt; salts_pos++) + { + scrypt_tmto_final = tmto; + } + + not_enough_memory = false; + + break; + } + + if (not_enough_memory == true) + { + event_log_error (hashcat_ctx, "Cannot allocate enough device memory. Perhaps retry with -n 1."); + + return -1; + } + + #if defined (DEBUG) + if (user_options->quiet == false) event_log_warning (hashcat_ctx, "SCRYPT tmto optimizer value set to: %lu, mem: %lu", scrypt_tmto_final, size_scrypt); + if (user_options->quiet == false) event_log_warning (hashcat_ctx, NULL); + #endif + } + + size_t size_scrypt4 = size_scrypt / 4; + + + + if (opencl_ctx->force_jit_compilation == 1500) + { + hc_asprintf (&build_opts_update, "%s -DDESCRYPT_SALT=%u", build_opts, hashes->salts_buf[0].salt_buf[0]); + } + else if ((opencl_ctx->force_jit_compilation == 8900) || (opencl_ctx->force_jit_compilation == 15700)) + { + hc_asprintf (&build_opts_update,"%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%" PRIu64, build_opts, hashes->salts_buf[0].scrypt_N, hashes->salts_buf[0].scrypt_r, hashes->salts_buf[0].scrypt_p, 1u << scrypt_tmto_final, (u64) scrypt_tmp_size / 16); + } + +} diff --git a/src/opencl.c b/src/opencl.c index 09cda16af..7a23e3e14 100644 --- a/src/opencl.c +++ b/src/opencl.c @@ -1212,7 +1212,7 @@ int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, status_ctx_t *status_ctx = hashcat_ctx->status_ctx; user_options_t *user_options = hashcat_ctx->user_options; - if (hashconfig->hash_mode == 2000) + if (user_options->stdout_flag == true) { return process_stdout (hashcat_ctx, device_param, pws_cnt); } @@ -4301,40 +4301,18 @@ static u32 get_kernel_threads (hashcat_ctx_t *hashcat_ctx, const hc_device_param int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) { - bitmap_ctx_t *bitmap_ctx = hashcat_ctx->bitmap_ctx; - folder_config_t *folder_config = hashcat_ctx->folder_config; - hashconfig_t *hashconfig = hashcat_ctx->hashconfig; - hashes_t *hashes = hashcat_ctx->hashes; - opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; - straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; - user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; - user_options_t *user_options = hashcat_ctx->user_options; + const bitmap_ctx_t *bitmap_ctx = hashcat_ctx->bitmap_ctx; + const folder_config_t *folder_config = hashcat_ctx->folder_config; + const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; + const hashes_t *hashes = hashcat_ctx->hashes; + const module_ctx_t *module_ctx = hashcat_ctx->module_ctx; + opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; + const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; + const user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; + const user_options_t *user_options = hashcat_ctx->user_options; if (opencl_ctx->enabled == false) return 0; - /** - * Some algorithm, like descrypt, can benefit from JIT compilation - */ - - opencl_ctx->force_jit_compilation = -1; - - if (hashconfig->hash_mode == 8900) - { - opencl_ctx->force_jit_compilation = 8900; - } - else if (hashconfig->hash_mode == 9300) - { - opencl_ctx->force_jit_compilation = 8900; - } - else if (hashconfig->hash_mode == 15700) - { - opencl_ctx->force_jit_compilation = 15700; - } - else if (hashconfig->hash_mode == 1500 && user_options->attack_mode == ATTACK_MODE_BF && hashes->salts_cnt == 1 && user_options->slow_candidates == false) - { - opencl_ctx->force_jit_compilation = 1500; - } - u32 hardware_power_all = 0; for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) @@ -4701,6 +4679,13 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) device_param->size_st_salts = size_st_salts; device_param->size_st_esalts = size_st_esalts; + u64 size_extra_buffer = 4; + + if (module_ctx->module_extra_buffer_size) + { + size_extra_buffer = module_ctx->module_extra_buffer_size (hashconfig, user_options, user_options_extra, hashes, device_param); + } + /** * some algorithms need a fixed kernel-loops count */ @@ -4721,155 +4706,6 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) device_param->size_rules = size_rules; device_param->size_rules_c = size_rules_c; - // scryptV stuff - - u64 scrypt_tmp_size = 0; - u64 scrypt_tmto_final = 0; - - u64 size_scrypt = 4; - - if ((hashconfig->hash_mode == 8900) || (hashconfig->hash_mode == 9300) || (hashconfig->hash_mode == 15700)) - { - // we need to check that all hashes have the same scrypt settings - - const u32 scrypt_N = hashes->salts_buf[0].scrypt_N; - const u32 scrypt_r = hashes->salts_buf[0].scrypt_r; - const u32 scrypt_p = hashes->salts_buf[0].scrypt_p; - - for (u32 i = 1; i < hashes->salts_cnt; i++) - { - if ((hashes->salts_buf[i].scrypt_N != scrypt_N) - || (hashes->salts_buf[i].scrypt_r != scrypt_r) - || (hashes->salts_buf[i].scrypt_p != scrypt_p)) - { - event_log_error (hashcat_ctx, "Mixed scrypt settings are not supported."); - - return -1; - } - } - - scrypt_tmp_size = (128 * scrypt_r * scrypt_p); - - hashconfig->tmp_size = scrypt_tmp_size; - - u32 tmto_start = 1; - u32 tmto_stop = 6; - - if (user_options->scrypt_tmto) - { - tmto_start = user_options->scrypt_tmto; - tmto_stop = user_options->scrypt_tmto; - } - - const u32 scrypt_threads = hashconfig->forced_kernel_threads; - - const u64 kernel_power_max = SCRYPT_MAX_ACCEL * device_processors * scrypt_threads; - - // size_pws - - const u64 size_pws = kernel_power_max * sizeof (pw_t); - - const u64 size_pws_amp = size_pws; - - // size_pws_comp - - const u64 size_pws_comp = kernel_power_max * (sizeof (u32) * 64); - - // size_pws_idx - - const u64 size_pws_idx = (kernel_power_max + 1) * sizeof (pw_idx_t); - - // size_tmps - - const u64 size_tmps = kernel_power_max * hashconfig->tmp_size; - - // size_hooks - - const u64 size_hooks = kernel_power_max * hashconfig->hook_size; - - const u64 scrypt_extra_space - = bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + bitmap_ctx->bitmap_size - + size_bfs - + size_combs - + size_digests - + size_esalts - + size_hooks - + size_markov_css - + size_plains - + size_pws - + size_pws_amp - + size_pws_comp - + size_pws_idx - + size_results - + size_root_css - + size_rules - + size_rules_c - + size_salts - + size_shown - + size_tm - + size_tmps - + size_st_digests - + size_st_salts - + size_st_esalts; - - bool not_enough_memory = true; - - u32 tmto; - - for (tmto = tmto_start; tmto <= tmto_stop; tmto++) - { - size_scrypt = (128 * scrypt_r) * scrypt_N; - - size_scrypt /= 1u << tmto; - - size_scrypt *= kernel_power_max; - - if ((size_scrypt / 4) > device_param->device_maxmem_alloc) - { - if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing single-block device memory allocatable for --scrypt-tmto %u.", tmto); - - continue; - } - - if ((size_scrypt + scrypt_extra_space) > device_param->device_available_mem) - { - if (user_options->quiet == false) event_log_warning (hashcat_ctx, "Increasing total device memory allocatable for --scrypt-tmto %u.", tmto); - - continue; - } - - for (u32 salts_pos = 0; salts_pos < hashes->salts_cnt; salts_pos++) - { - scrypt_tmto_final = tmto; - } - - not_enough_memory = false; - - break; - } - - if (not_enough_memory == true) - { - event_log_error (hashcat_ctx, "Cannot allocate enough device memory. Perhaps retry with -n 1."); - - return -1; - } - - #if defined (DEBUG) - if (user_options->quiet == false) event_log_warning (hashcat_ctx, "SCRYPT tmto optimizer value set to: %lu, mem: %lu", scrypt_tmto_final, size_scrypt); - if (user_options->quiet == false) event_log_warning (hashcat_ctx, NULL); - #endif - } - - size_t size_scrypt4 = size_scrypt / 4; - /** * default building options */ @@ -5052,7 +4888,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) char **kernel_sources = &kernel_sources_buf; - if (opencl_ctx->force_jit_compilation == -1) + if (module_ctx->module_jit_build_options == NULL) { if (cached == false) { @@ -5149,13 +4985,11 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) char *build_opts_update; - if (opencl_ctx->force_jit_compilation == 1500) + if (module_ctx->module_jit_build_options) { - hc_asprintf (&build_opts_update, "%s -DDESCRYPT_SALT=%u", build_opts, hashes->salts_buf[0].salt_buf[0]); - } - else if ((opencl_ctx->force_jit_compilation == 8900) || (opencl_ctx->force_jit_compilation == 15700)) - { - hc_asprintf (&build_opts_update,"%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%" PRIu64, build_opts, hashes->salts_buf[0].scrypt_N, hashes->salts_buf[0].scrypt_r, hashes->salts_buf[0].scrypt_p, 1u << scrypt_tmto_final, (u64) scrypt_tmp_size / 16); + char *jit_build_options = module_ctx->module_jit_build_options (hashconfig, user_options, user_options_extra, hashes, device_param); + + hc_asprintf (&build_opts_update, "%s %s", build_opts, jit_build_options); } else { @@ -5524,10 +5358,10 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL, &device_param->d_digests_shown); if (CL_rc == -1) return -1; CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL, &device_param->d_salt_bufs); if (CL_rc == -1) return -1; CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_results, NULL, &device_param->d_result); if (CL_rc == -1) return -1; - CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV0_buf); if (CL_rc == -1) return -1; - CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV1_buf); if (CL_rc == -1) return -1; - CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV2_buf); if (CL_rc == -1) return -1; - CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV3_buf); if (CL_rc == -1) return -1; + CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_extra_buffer, NULL, &device_param->d_extra0_buf); if (CL_rc == -1) return -1; + CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_extra_buffer, NULL, &device_param->d_extra1_buf); if (CL_rc == -1) return -1; + CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_extra_buffer, NULL, &device_param->d_extra2_buf); if (CL_rc == -1) return -1; + CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_WRITE, size_extra_buffer, NULL, &device_param->d_extra3_buf); if (CL_rc == -1) return -1; CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_ONLY, size_st_digests, NULL, &device_param->d_st_digests_buf); if (CL_rc == -1) return -1; CL_rc = hc_clCreateBuffer (hashcat_ctx, device_param->context, CL_MEM_READ_ONLY, size_st_salts, NULL, &device_param->d_st_salts_buf); if (CL_rc == -1) return -1; @@ -5640,10 +5474,10 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) device_param->kernel_params[17] = &device_param->d_salt_bufs; device_param->kernel_params[18] = &device_param->d_esalt_bufs; device_param->kernel_params[19] = &device_param->d_result; - device_param->kernel_params[20] = &device_param->d_scryptV0_buf; - device_param->kernel_params[21] = &device_param->d_scryptV1_buf; - device_param->kernel_params[22] = &device_param->d_scryptV2_buf; - device_param->kernel_params[23] = &device_param->d_scryptV3_buf; + device_param->kernel_params[20] = &device_param->d_extra0_buf; + device_param->kernel_params[21] = &device_param->d_extra1_buf; + device_param->kernel_params[22] = &device_param->d_extra2_buf; + device_param->kernel_params[23] = &device_param->d_extra3_buf; device_param->kernel_params[24] = &device_param->kernel_params_buf32[24]; device_param->kernel_params[25] = &device_param->kernel_params_buf32[25]; device_param->kernel_params[26] = &device_param->kernel_params_buf32[26]; @@ -6661,10 +6495,10 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx) + size_rules + size_rules_c + size_salts - + size_scrypt4 - + size_scrypt4 - + size_scrypt4 - + size_scrypt4 + + size_extra_buffer + + size_extra_buffer + + size_extra_buffer + + size_extra_buffer + size_shown + size_tm + size_tmps @@ -6930,10 +6764,10 @@ void opencl_session_destroy (hashcat_ctx_t *hashcat_ctx) if (device_param->d_tmps) hc_clReleaseMemObject (hashcat_ctx, device_param->d_tmps); if (device_param->d_hooks) hc_clReleaseMemObject (hashcat_ctx, device_param->d_hooks); if (device_param->d_result) hc_clReleaseMemObject (hashcat_ctx, device_param->d_result); - if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_scryptV0_buf); - if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_scryptV1_buf); - if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_scryptV2_buf); - if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_scryptV3_buf); + if (device_param->d_extra0_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_extra0_buf); + if (device_param->d_extra1_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_extra1_buf); + if (device_param->d_extra2_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_extra2_buf); + if (device_param->d_extra3_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_extra3_buf); if (device_param->d_root_css_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_root_css_buf); if (device_param->d_markov_css_buf) hc_clReleaseMemObject (hashcat_ctx, device_param->d_markov_css_buf); if (device_param->d_tm_c) hc_clReleaseMemObject (hashcat_ctx, device_param->d_tm_c); @@ -7003,10 +6837,10 @@ void opencl_session_destroy (hashcat_ctx_t *hashcat_ctx) device_param->d_tmps = NULL; device_param->d_hooks = NULL; device_param->d_result = NULL; - device_param->d_scryptV0_buf = NULL; - device_param->d_scryptV1_buf = NULL; - device_param->d_scryptV2_buf = NULL; - device_param->d_scryptV3_buf = NULL; + device_param->d_extra0_buf = NULL; + device_param->d_extra1_buf = NULL; + device_param->d_extra2_buf = NULL; + device_param->d_extra3_buf = NULL; device_param->d_root_css_buf = NULL; device_param->d_markov_css_buf = NULL; device_param->d_tm_c = NULL;