X-Git-Url: https://www.flypig.org.uk/git/?a=blobdiff_plain;f=src%2Fhashcat.c;h=41b61444158f509ad02efb838b70408309d18baa;hb=6be99f523c1f5b86818825923d04bc22080f43fb;hp=36a6e84aa1ba9bee9a1153ee90a2173e266cee43;hpb=3a275a95e63302480110568f2bbe15281c2cfc2b;p=hashcat.git diff --git a/src/hashcat.c b/src/hashcat.c index 36a6e84..41b6144 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -1,4 +1,4 @@ - /** +/** * Authors.....: Jens Steube * Gabriele Gristina * magnum @@ -6,7 +6,7 @@ * License.....: MIT */ -#ifdef OSX +#ifdef DARWIN #include #endif @@ -78,7 +78,7 @@ double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 }; #define NVIDIA_SPIN_DAMP 100 #define GPU_TEMP_DISABLE 0 #define GPU_TEMP_ABORT 90 -#define GPU_TEMP_RETAIN 65 +#define GPU_TEMP_RETAIN 75 #define WORKLOAD_PROFILE 2 #define KERNEL_ACCEL 0 #define KERNEL_LOOPS 0 @@ -916,15 +916,7 @@ void status_display_machine_readable () * flush */ - #ifdef _WIN - fputc ('\r', out); - fputc ('\n', out); - #endif - - #ifdef _POSIX - fputc ('\n', out); - #endif - + fputs (EOL, out); fflush (out); } @@ -2398,7 +2390,7 @@ static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt) uint plain_len = 0; - const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know + const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know if (data.attack_mode == ATTACK_MODE_STRAIGHT) { @@ -2657,8 +2649,8 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co { uint num_elements = num; - device_param->kernel_params_buf32[30] = data.combs_mode; - device_param->kernel_params_buf32[31] = num; + device_param->kernel_params_buf32[33] = data.combs_mode; + device_param->kernel_params_buf32[34] = num; uint kernel_threads = device_param->kernel_threads; @@ -2675,9 +2667,6 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co case KERN_RUN_3: kernel = device_param->kernel3; break; } - hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]); - hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]); - hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]); hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]); hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]); hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]); @@ -2686,6 +2675,9 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]); hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]); hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]); + hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]); + hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]); + hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]); cl_event event; @@ -3037,14 +3029,15 @@ static void choose_kernel (hc_device_param_t *device_param, const uint attack_ex loop_left = MIN (loop_left, loop_step); - device_param->kernel_params_buf32[25] = loop_pos; - device_param->kernel_params_buf32[26] = loop_left; + device_param->kernel_params_buf32[28] = loop_pos; + device_param->kernel_params_buf32[29] = loop_left; 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 (data.devices_status == STATUS_QUIT) break; + if (data.devices_status == STATUS_BYPASS) break; /** * speed @@ -3177,9 +3170,9 @@ static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, { const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel; - device_param->kernel_params_buf32[25] = 0; - device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set - device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes + device_param->kernel_params_buf32[28] = 0; + device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set + device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { @@ -3503,9 +3496,9 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) salt_t *salt_buf = &data.salts_buf[salt_pos]; - device_param->kernel_params_buf32[24] = salt_pos; - device_param->kernel_params_buf32[28] = salt_buf->digests_cnt; - device_param->kernel_params_buf32[29] = salt_buf->digests_offset; + device_param->kernel_params_buf32[27] = salt_pos; + device_param->kernel_params_buf32[31] = salt_buf->digests_cnt; + device_param->kernel_params_buf32[32] = salt_buf->digests_offset; FILE *combs_fp = device_param->combs_fp; @@ -3541,7 +3534,7 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) device_param->innerloop_pos = innerloop_pos; device_param->innerloop_left = innerloop_left; - device_param->kernel_params_buf32[27] = innerloop_left; + device_param->kernel_params_buf32[30] = innerloop_left; // i think we can get rid of this if (innerloop_left == 0) @@ -3701,6 +3694,7 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) if (data.devices_status == STATUS_CRACKED) break; if (data.devices_status == STATUS_ABORTED) break; if (data.devices_status == STATUS_QUIT) break; + if (data.devices_status == STATUS_BYPASS) break; /** * result @@ -4163,7 +4157,7 @@ static void *thread_monitor (void *p) return (p); } - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while (data.shutdown_inner == 0) { hc_sleep (sleep_time); @@ -4349,7 +4343,7 @@ static void *thread_monitor (void *p) time (&runtime_cur); - int runtime_left = data.runtime_start + data.runtime - runtime_cur; + int runtime_left = data.proc_start + data.runtime - runtime_cur; if (runtime_left <= 0) { @@ -4385,7 +4379,7 @@ static void *thread_monitor (void *p) if (status_left == 0) { - //hc_thread_mutex_lock (mux_display); + hc_thread_mutex_lock (mux_display); if (data.quiet == 0) clear_prompt (); @@ -4395,7 +4389,7 @@ static void *thread_monitor (void *p) if (data.quiet == 0) log_info (""); - //hc_thread_mutex_unlock (mux_display); + hc_thread_mutex_unlock (mux_display); status_left = data.status_timer; } @@ -4452,7 +4446,7 @@ static void *thread_outfile_remove (void *p) uint check_left = outfile_check_timer; // or 1 if we want to check it at startup - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while (data.shutdown_inner == 0) { hc_sleep (1); @@ -4780,7 +4774,7 @@ static uint get_work (hc_device_param_t *device_param, const u64 max) hc_thread_mutex_lock (mux_dispatcher); const u64 words_cur = data.words_cur; - const u64 words_base = (data.limit == 0) ? data.words_base : data.limit; + const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base); device_param->words_off = words_cur; @@ -4830,7 +4824,7 @@ static void *thread_calc_stdin (void *p) const uint attack_kern = data.attack_kern; - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { hc_thread_mutex_lock (mux_dispatcher); @@ -4958,7 +4952,7 @@ static void *thread_calc (void *p) if (attack_mode == ATTACK_MODE_BF) { - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { const uint work = get_work (device_param, -1); @@ -5070,7 +5064,7 @@ static void *thread_calc (void *p) u64 words_cur = 0; - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { u64 words_off = 0; u64 words_fin = 0; @@ -5250,12 +5244,12 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po salt_t *salt_buf = &data.salts_buf[salt_pos]; - device_param->kernel_params_buf32[24] = salt_pos; - device_param->kernel_params_buf32[27] = 1; - device_param->kernel_params_buf32[28] = salt_buf->digests_cnt; - device_param->kernel_params_buf32[29] = salt_buf->digests_offset; - device_param->kernel_params_buf32[30] = 0; - device_param->kernel_params_buf32[31] = 1; + device_param->kernel_params_buf32[27] = salt_pos; + device_param->kernel_params_buf32[30] = 1; + device_param->kernel_params_buf32[31] = salt_buf->digests_cnt; + device_param->kernel_params_buf32[32] = salt_buf->digests_offset; + device_param->kernel_params_buf32[33] = 0; + device_param->kernel_params_buf32[34] = 1; char *dictfile_old = data.dictfile; @@ -5289,8 +5283,8 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po loop_left = MIN (loop_left, loop_step); - device_param->kernel_params_buf32[25] = loop_pos; - device_param->kernel_params_buf32[26] = loop_left; + device_param->kernel_params_buf32[28] = loop_pos; + device_param->kernel_params_buf32[29] = loop_left; run_kernel (KERN_RUN_2, device_param, 1, false, 0); } @@ -5308,14 +5302,14 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po * cleanup */ - device_param->kernel_params_buf32[24] = 0; - device_param->kernel_params_buf32[25] = 0; - device_param->kernel_params_buf32[26] = 0; device_param->kernel_params_buf32[27] = 0; device_param->kernel_params_buf32[28] = 0; device_param->kernel_params_buf32[29] = 0; device_param->kernel_params_buf32[30] = 0; device_param->kernel_params_buf32[31] = 0; + device_param->kernel_params_buf32[32] = 0; + device_param->kernel_params_buf32[33] = 0; + device_param->kernel_params_buf32[34] = 0; data.dictfile = dictfile_old; @@ -7358,17 +7352,19 @@ int main (int argc, char **argv) data.status = status; } - uint i_threads_cnt = 0; + uint outer_threads_cnt = 0; - hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); + hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); + + data.shutdown_outer = 0; if (keyspace == 0 && benchmark == 0 && stdout_flag == 0) { if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK)) { - hc_thread_create (i_threads[i_threads_cnt], thread_keypress, NULL); + hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL); - i_threads_cnt++; + outer_threads_cnt++; } } @@ -13534,7 +13530,7 @@ int main (int argc, char **argv) if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) { - log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf); + log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf); memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data @@ -13544,7 +13540,7 @@ int main (int argc, char **argv) /* its so slow if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule)) { - log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf); + log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf); continue; } @@ -13648,7 +13644,7 @@ int main (int argc, char **argv) * generate NOP rules */ - if (kernel_rules_cnt == 0) + if ((rp_files_cnt == 0) && (rp_gen == 0)) { kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t)); @@ -13660,6 +13656,13 @@ int main (int argc, char **argv) data.kernel_rules_cnt = kernel_rules_cnt; data.kernel_rules_buf = kernel_rules_buf; + if (kernel_rules_cnt == 0) + { + log_error ("ERROR: No valid rules left"); + + return (-1); + } + /** * OpenCL platforms: detect */ @@ -14177,7 +14180,7 @@ int main (int argc, char **argv) device_param->device_name_chksum = device_name_chksum; - // device_processor_cores + // vendor specific if (device_param->device_type & CL_DEVICE_TYPE_GPU) { @@ -14200,28 +14203,9 @@ int main (int argc, char **argv) } } - // device_processor_cores - - if (device_type & CL_DEVICE_TYPE_CPU) - { - cl_uint device_processor_cores = 1; - - device_param->device_processor_cores = device_processor_cores; - } - if (device_type & CL_DEVICE_TYPE_GPU) { - if (device_vendor_id == VENDOR_ID_AMD) - { - cl_uint device_processor_cores = 0; - - #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043 - - hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL); - - device_param->device_processor_cores = device_processor_cores; - } - else if (device_vendor_id == VENDOR_ID_NV) + if (device_vendor_id == VENDOR_ID_NV) { cl_uint kernel_exec_timeout = 0; @@ -14231,14 +14215,6 @@ int main (int argc, char **argv) device_param->kernel_exec_timeout = kernel_exec_timeout; - cl_uint device_processor_cores = 0; - - #define CL_DEVICE_WARP_SIZE_NV 0x4003 - - hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL); - - device_param->device_processor_cores = device_processor_cores; - cl_uint sm_minor = 0; cl_uint sm_major = 0; @@ -14274,12 +14250,6 @@ int main (int argc, char **argv) device_param->nvidia_spin_damp /= 100; } - else - { - cl_uint device_processor_cores = 1; - - device_param->device_processor_cores = device_processor_cores; - } } // display results @@ -14537,9 +14507,9 @@ int main (int argc, char **argv) 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); + // doesn't seem to create any advantages + //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); } } } @@ -14646,9 +14616,6 @@ int main (int argc, char **argv) * OpenCL devices: allocate buffer for device specific information */ - int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int)); - int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int)); - ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState)); int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int)); @@ -15011,7 +14978,6 @@ int main (int argc, char **argv) const char *device_name_chksum = device_param->device_name_chksum; const u32 device_processors = device_param->device_processors; - const u32 device_processor_cores = device_param->device_processor_cores; /** * create context for each device @@ -15045,7 +15011,9 @@ int main (int argc, char **argv) if (hash_mode == 3000) kernel_threads = 64; // DES if (hash_mode == 3200) kernel_threads = 8; // Blowfish if (hash_mode == 7500) kernel_threads = 64; // RC4 + if (hash_mode == 8900) kernel_threads = 64; // Scrypt if (hash_mode == 9000) kernel_threads = 8; // Blowfish + if (hash_mode == 9300) kernel_threads = 64; // Scrypt if (hash_mode == 9700) kernel_threads = 64; // RC4 if (hash_mode == 9710) kernel_threads = 64; // RC4 if (hash_mode == 9800) kernel_threads = 64; // RC4 @@ -15091,10 +15059,28 @@ int main (int argc, char **argv) // scryptV stuff - size_t size_scryptV = 1; + size_t size_scrypt = 4; if ((hash_mode == 8900) || (hash_mode == 9300)) { + // we need to check that all hashes have the same scrypt settings + + const u32 scrypt_N = data.salts_buf[0].scrypt_N; + const u32 scrypt_r = data.salts_buf[0].scrypt_r; + const u32 scrypt_p = data.salts_buf[0].scrypt_p; + + for (uint i = 1; i < salts_cnt; i++) + { + if ((data.salts_buf[i].scrypt_N != scrypt_N) + || (data.salts_buf[i].scrypt_r != scrypt_r) + || (data.salts_buf[i].scrypt_p != scrypt_p)) + { + log_error ("ERROR: Mixed scrypt settings not supported"); + + return -1; + } + } + uint tmto_start = 0; uint tmto_stop = 10; @@ -15105,14 +15091,13 @@ int main (int argc, char **argv) else { // in case the user did not specify the tmto manually - // use some values known to run best (tested on 290x for AMD and 980ti for NV) - // but set the lower end only in case the user has a device with too less memory + // use some values known to run best (tested on 290x for AMD and GTX1080 for NV) if (hash_mode == 8900) { if (device_param->device_vendor_id == VENDOR_ID_AMD) { - tmto_start = 1; + tmto_start = 3; } else if (device_param->device_vendor_id == VENDOR_ID_NV) { @@ -15127,48 +15112,60 @@ int main (int argc, char **argv) } else if (device_param->device_vendor_id == VENDOR_ID_NV) { - tmto_start = 2; + tmto_start = 4; } } } - for (uint tmto = tmto_start; tmto < tmto_stop; tmto++) + data.scrypt_tmp_size = (128 * scrypt_r); + + device_param->kernel_accel_min = 1; + device_param->kernel_accel_max = 8; + + uint tmto; + + for (tmto = tmto_start; tmto < tmto_stop; tmto++) { - // TODO: in theory the following calculation needs to be done per salt, not global - // we assume all hashes have the same scrypt settings + size_scrypt = (128 * scrypt_r) * scrypt_N; - size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N; + size_scrypt /= 1 << tmto; - size_scryptV /= 1 << tmto; + size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max; - size_scryptV *= device_processors * device_processor_cores; + if ((size_scrypt / 4) > device_param->device_maxmem_alloc) + { + if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto); + + continue; + } - if (size_scryptV > device_param->device_maxmem_alloc) + if (size_scrypt > device_param->device_global_mem) { - if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto); + if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto); continue; } for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++) { - data.salts_buf[salts_pos].scrypt_tmto = tmto; - data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores; + data.scrypt_tmto_final = tmto; } break; } - if (data.salts_buf[0].scrypt_phy == 0) + if (tmto == tmto_stop) { log_error ("ERROR: Can't allocate enough device memory"); return -1; } - if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV); + if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt); } + size_t size_scrypt4 = size_scrypt / 4; + /** * some algorithms need a fixed kernel-loops count */ @@ -15294,11 +15291,11 @@ int main (int argc, char **argv) case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break; case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break; case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break; - case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break; + case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break; case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break; case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break; case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break; - case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break; + case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break; case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break; case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break; case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break; @@ -15385,7 +15382,10 @@ int main (int argc, char **argv) + size_rules + size_rules_c + size_salts - + size_scryptV + + size_scrypt4 + + size_scrypt4 + + size_scrypt4 + + size_scrypt4 + size_shown + size_tm + size_tmps; @@ -15456,8 +15456,6 @@ int main (int argc, char **argv) snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real); - myfree (cpath_real); - #else snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir); @@ -15475,15 +15473,69 @@ int main (int argc, char **argv) snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real); - myfree (cpath_real); - #endif + // include check + // this test needs to be done manually because of osx opencl runtime + // if there's a problem with permission, its not reporting back and erroring out silently + + #define files_cnt 15 + + const char *files_names[files_cnt] = + { + "inc_cipher_aes256.cl", + "inc_cipher_serpent256.cl", + "inc_cipher_twofish256.cl", + "inc_common.cl", + "inc_comp_multi_bs.cl", + "inc_comp_multi.cl", + "inc_comp_single_bs.cl", + "inc_comp_single.cl", + "inc_hash_constants.h", + "inc_hash_functions.cl", + "inc_rp.cl", + "inc_rp.h", + "inc_simd.cl", + "inc_types.cl", + "inc_vendor.cl", + }; + + for (int i = 0; i < files_cnt; i++) + { + char path[1024] = { 0 }; + + snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]); + + FILE *fd = fopen (path, "r"); + + if (fd == NULL) + { + log_error ("ERROR: %s: fopen(): %s", path, strerror (errno)); + + return -1; + } + + char buf[1]; + + size_t n = fread (buf, 1, 1, fd); + + if (n != 1) + { + log_error ("ERROR: %s: fread(): %s", path, strerror (errno)); + + return -1; + } + + fclose (fd); + } + + myfree (cpath_real); + // we don't have sm_* on vendors not NV but it doesn't matter char build_opts_new[1024] = { 0 }; - snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type); + snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type); strncpy (build_opts, build_opts_new, sizeof (build_opts)); @@ -15617,11 +15669,11 @@ int main (int argc, char **argv) if (force_jit_compilation == 1500) { - snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]); + snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]); } else if (force_jit_compilation == 8900) { - snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto); + snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16); } else { @@ -15893,7 +15945,10 @@ int main (int argc, char **argv) device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL); device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL); device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL); - device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL); + device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL); @@ -15961,17 +16016,17 @@ int main (int argc, char **argv) * kernel args */ - device_param->kernel_params_buf32[21] = bitmap_mask; - device_param->kernel_params_buf32[22] = bitmap_shift1; - device_param->kernel_params_buf32[23] = bitmap_shift2; - device_param->kernel_params_buf32[24] = 0; // salt_pos - device_param->kernel_params_buf32[25] = 0; // loop_pos - device_param->kernel_params_buf32[26] = 0; // loop_cnt - device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt - device_param->kernel_params_buf32[28] = 0; // digests_cnt - device_param->kernel_params_buf32[29] = 0; // digests_offset - device_param->kernel_params_buf32[30] = 0; // combs_mode - device_param->kernel_params_buf32[31] = 0; // gid_max + device_param->kernel_params_buf32[24] = bitmap_mask; + device_param->kernel_params_buf32[25] = bitmap_shift1; + device_param->kernel_params_buf32[26] = bitmap_shift2; + device_param->kernel_params_buf32[27] = 0; // salt_pos + device_param->kernel_params_buf32[28] = 0; // loop_pos + device_param->kernel_params_buf32[29] = 0; // loop_cnt + device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt + device_param->kernel_params_buf32[31] = 0; // digests_cnt + device_param->kernel_params_buf32[32] = 0; // digests_offset + device_param->kernel_params_buf32[33] = 0; // combs_mode + device_param->kernel_params_buf32[34] = 0; // gid_max device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) ? &device_param->d_pws_buf @@ -15995,10 +16050,10 @@ int main (int argc, char **argv) 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_scryptV_buf; - device_param->kernel_params[21] = &device_param->kernel_params_buf32[21]; - device_param->kernel_params[22] = &device_param->kernel_params_buf32[22]; - device_param->kernel_params[23] = &device_param->kernel_params_buf32[23]; + 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[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]; @@ -16007,6 +16062,9 @@ int main (int argc, char **argv) device_param->kernel_params[29] = &device_param->kernel_params_buf32[29]; device_param->kernel_params[30] = &device_param->kernel_params_buf32[30]; device_param->kernel_params[31] = &device_param->kernel_params_buf32[31]; + device_param->kernel_params[32] = &device_param->kernel_params_buf32[32]; + device_param->kernel_params[33] = &device_param->kernel_params_buf32[33]; + device_param->kernel_params[34] = &device_param->kernel_params_buf32[34]; device_param->kernel_params_mp_buf64[3] = 0; device_param->kernel_params_mp_buf32[4] = 0; @@ -16170,7 +16228,7 @@ int main (int argc, char **argv) hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp); hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp); - for (uint i = 0; i <= 20; i++) + for (uint i = 0; i <= 23; i++) { hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]); hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]); @@ -16180,7 +16238,7 @@ int main (int argc, char **argv) if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]); } - for (uint i = 21; i <= 31; i++) + for (uint i = 24; i <= 34; i++) { hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]); hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]); @@ -16312,9 +16370,6 @@ int main (int argc, char **argv) const int fanspeed = hm_get_fanspeed_with_device_id (device_id); const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id); - temp_retain_fanspeed_value[device_id] = fanspeed; - temp_retain_fanpolicy_value[device_id] = fanpolicy; - // we also set it to tell the OS we take control over the fan and it's automatic controller // if it was set to automatic. we do not control user-defined fanspeeds. @@ -17227,21 +17282,16 @@ int main (int argc, char **argv) * status and monitor threads */ - if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { data.devices_status = STATUS_STARTING; } - uint ni_threads_cnt = 0; - - hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); + uint inner_threads_cnt = 0; - if (keyspace == 0 && benchmark == 0 && stdout_flag == 0) - { - hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL); + hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); - ni_threads_cnt++; - } + data.shutdown_inner = 0; /** * Outfile remove @@ -17249,6 +17299,10 @@ int main (int argc, char **argv) if (keyspace == 0 && benchmark == 0 && stdout_flag == 0) { + hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL); + + inner_threads_cnt++; + if (outfile_check_timer != 0) { if (data.outfile_check_directory != NULL) @@ -17258,9 +17312,9 @@ int main (int argc, char **argv) !((hash_mode >= 13700) && (hash_mode <= 13799)) && (hash_mode != 9000)) { - hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL); + hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL); - ni_threads_cnt++; + inner_threads_cnt++; } else { @@ -17561,7 +17615,10 @@ int main (int argc, char **argv) logfile_sub_msg ("START"); - data.devices_status = STATUS_INIT; + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_INIT; + } memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64)); memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64)); @@ -18089,7 +18146,10 @@ int main (int argc, char **argv) hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t)); - data.devices_status = STATUS_AUTOTUNE; + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_AUTOTUNE; + } for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { @@ -18143,7 +18203,10 @@ int main (int argc, char **argv) * create cracker threads */ - data.devices_status = STATUS_RUNNING; + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_RUNNING; + } if (initial_restore_done == 0) { @@ -18192,7 +18255,7 @@ int main (int argc, char **argv) local_free (c_threads); - if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT) && (data.devices_status != STATUS_BYPASS)) + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { data.devices_status = STATUS_EXHAUSTED; } @@ -18256,11 +18319,21 @@ int main (int argc, char **argv) global_free (subid); - // from this point we handle bypass as exhausted + // from this point we handle bypass as running if (data.devices_status == STATUS_BYPASS) { - data.devices_status = STATUS_EXHAUSTED; + data.devices_status = STATUS_RUNNING; + } + + // and overwrite benchmark aborts as well + + if (data.benchmark == 1) + { + if (data.devices_status == STATUS_ABORTED) + { + data.devices_status = STATUS_RUNNING; + } } // finalize task @@ -18326,14 +18399,16 @@ int main (int argc, char **argv) } } - // wait for non-interactive threads + // wait for inner threads - for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++) + data.shutdown_inner = 1; + + for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++) { - hc_thread_wait (1, &ni_threads[thread_idx]); + hc_thread_wait (1, &inner_threads[thread_idx]); } - local_free (ni_threads); + local_free (inner_threads); // we dont need restore file anymore if (data.restore_disable == 0) @@ -18398,7 +18473,10 @@ int main (int argc, char **argv) if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps); if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks); if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result); - if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf); + if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf); + if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf); + if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf); + if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf); if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf); if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf); if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c); @@ -18428,7 +18506,7 @@ int main (int argc, char **argv) #ifdef HAVE_HWMON if (gpu_temp_disable == 0) { - if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here + if (gpu_temp_retain != 0) { hc_thread_mutex_lock (mux_adl); @@ -18440,30 +18518,24 @@ int main (int argc, char **argv) if (data.hm_device[device_id].fan_set_supported == 1) { - int fanspeed = temp_retain_fanspeed_value[device_id]; - int fanpolicy = temp_retain_fanpolicy_value[device_id]; + int rc = -1; - if (fanpolicy == 1) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - int rc = -1; - - if (device_param->device_vendor_id == VENDOR_ID_AMD) - { - rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0); - } - else if (device_param->device_vendor_id == VENDOR_ID_NV) - { - #ifdef LINUX - rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE); - #endif - - #ifdef WIN - rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, fanpolicy); - #endif - } + rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0); + } + else if (device_param->device_vendor_id == VENDOR_ID_NV) + { + #ifdef LINUX + rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE); + #endif - if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1); + #ifdef WIN + rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0); + #endif } + + if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1); } } @@ -18473,7 +18545,7 @@ int main (int argc, char **argv) // reset power tuning - if (powertune_enable == 1) // VENDOR_ID_AMD is implied here + if (powertune_enable == 1) { hc_thread_mutex_lock (mux_adl); @@ -18624,7 +18696,6 @@ int main (int argc, char **argv) local_free (bitmap_s2_d); #ifdef HAVE_HWMON - local_free (temp_retain_fanspeed_value); local_free (od_clock_mem_status); local_free (od_power_control_status); local_free (nvml_power_limit); @@ -18655,14 +18726,16 @@ int main (int argc, char **argv) if (data.devices_status == STATUS_QUIT) break; } - // wait for interactive threads + // wait for outer threads + + data.shutdown_outer = 1; - for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++) + for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++) { - hc_thread_wait (1, &i_threads[thread_idx]); + hc_thread_wait (1, &outer_threads[thread_idx]); } - local_free (i_threads); + local_free (outer_threads); // destroy others mutex