X-Git-Url: https://www.flypig.org.uk/git/?a=blobdiff_plain;f=src%2Fhashcat.c;h=ab38fe2b2de3a6f3b79b908dd6407ec6a73107eb;hb=217f9e600443c575755244788eaab5b0db758b88;hp=031ee99b5d60ee9b4bf4a7aed8faf6e0c172fb27;hpb=16ffade75e2a3c9241d5ee05493529f32c6a3507;p=hashcat.git diff --git a/src/hashcat.c b/src/hashcat.c index 031ee99..ab38fe2 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -1,4 +1,4 @@ -/** + /** * Authors.....: Jens Steube * Gabriele Gristina * magnum @@ -150,6 +150,8 @@ double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 }; #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143 +#define NVIDIA_100PERCENTCPU_WORKAROUND 100 + #define global_free(attr) \ { \ myfree ((void *) data.attr); \ @@ -164,6 +166,12 @@ double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 }; attr = NULL; \ } +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +#define HC_API_CALL __stdcall +#else +#define HC_API_CALL +#endif + static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] = { 900, @@ -570,6 +578,7 @@ const char *USAGE_BIG[] = " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems", " 501 | Juniper IVE | Operating-Systems", " 5800 | Android PIN | Operating-Systems", + " 13800 | Windows 8+ phone PIN/Password | Operating-Systems", " 8100 | Citrix Netscaler | Operating-Systems", " 8500 | RACF | Operating-Systems", " 7200 | GRUB 2 | Operating-Systems", @@ -1531,6 +1540,12 @@ void status_display () } #ifdef HAVE_HWMON + + if (data.devices_status == STATUS_EXHAUSTED) return; + if (data.devices_status == STATUS_CRACKED) return; + if (data.devices_status == STATUS_ABORTED) return; + if (data.devices_status == STATUS_QUIT) return; + if (data.gpu_temp_disable == 0) { hc_thread_mutex_lock (mux_adl); @@ -1614,6 +1629,7 @@ void status_display () hc_thread_mutex_unlock (mux_adl); } + #endif // HAVE_HWMON } @@ -2389,42 +2405,6 @@ static void save_hash () unlink (old_hashfile); } -static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all) -{ - // function called only in case kernel_power_all > words_left - - float kernel_power_div = (float) (total_left) / kernel_power_all; - - kernel_power_div += kernel_power_div / 100; - - u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div); - - while (kernel_power_new < total_left) - { - kernel_power_div += kernel_power_div / 100; - - kernel_power_new = (u32) (kernel_power_all * kernel_power_div); - } - - if (data.quiet == 0) - { - clear_prompt (); - - //log_info (""); - - log_info ("INFO: approaching final keyspace, workload adjusted"); - log_info (""); - - fprintf (stdout, "%s", PROMPT); - - fflush (stdout); - } - - //if ((kernel_power_all * kernel_power_div) < 8) return 1; - - return kernel_power_div; -} - static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update) { uint num_elements = num; @@ -3422,7 +3402,10 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) * result */ - check_cracked (device_param, salt_pos); + if (data.benchmark == 0) + { + check_cracked (device_param, salt_pos); + } /** * progress @@ -3816,7 +3799,9 @@ static void *thread_monitor (void *p) uint status_left = data.status_timer; #ifdef HAVE_HWMON - uint hwmon_check = 0; + uint hwmon_check = 0; + + int slowdown_warnings = 0; // these variables are mainly used for fan control @@ -3882,6 +3867,62 @@ static void *thread_monitor (void *p) #ifdef HAVE_HWMON + if (hwmon_check == 1) + { + hc_thread_mutex_lock (mux_adl); + + for (uint device_id = 0; device_id < data.devices_cnt; device_id++) + { + hc_device_param_t *device_param = &data.devices_param[device_id]; + + if (device_param->skipped) continue; + + if (device_param->device_vendor_id == VENDOR_ID_NV) + { + if (data.hm_nvapi) + { + NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 }; + NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 }; + + perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1); + perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1); + + hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info); + + perfPolicies_status.info_value = perfPolicies_info.info_value; + + hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status); + + if (perfPolicies_status.throttle & 2) + { + if (slowdown_warnings < 3) + { + if (data.quiet == 0) clear_prompt (); + + log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1); + + if (slowdown_warnings == 2) + { + log_info (""); + } + + if (data.quiet == 0) fprintf (stdout, "%s", PROMPT); + if (data.quiet == 0) fflush (stdout); + + slowdown_warnings++; + } + } + else + { + slowdown_warnings = 0; + } + } + } + } + + hc_thread_mutex_unlock (mux_adl); + } + if (hwmon_check == 1) { hc_thread_mutex_lock (mux_adl); @@ -4385,14 +4426,43 @@ static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int //} } -static u32 get_power (const u32 kernel_power) +static void set_kernel_power_final (const u64 kernel_power_final) +{ + if (data.quiet == 0) + { + clear_prompt (); + + //log_info (""); + + log_info ("INFO: approaching final keyspace, workload adjusted"); + log_info (""); + + fprintf (stdout, "%s", PROMPT); + + fflush (stdout); + } + + data.kernel_power_final = kernel_power_final; +} + +static u32 get_power (hc_device_param_t *device_param) { - if (data.kernel_power_div) + const u64 kernel_power_final = data.kernel_power_final; + + if (kernel_power_final) { - return (float) kernel_power * data.kernel_power_div; + const double device_factor = (double) device_param->hardware_power / data.hardware_power_all; + + const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor); + + // work should be at least the hardware power available without any accelerator + + const u64 work = MAX (words_left_device, device_param->hardware_power); + + return work; } - return kernel_power; + return device_param->kernel_power; } static uint get_work (hc_device_param_t *device_param, const u64 max) @@ -4404,17 +4474,19 @@ static uint get_work (hc_device_param_t *device_param, const u64 max) device_param->words_off = words_cur; + const u64 kernel_power_all = data.kernel_power_all; + const u64 words_left = words_base - words_cur; - if (data.kernel_power_all > words_left) + if (words_left < kernel_power_all) { - if (data.kernel_power_div == 0) + if (data.kernel_power_final == 0) { - data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all); + set_kernel_power_final (words_left); } } - const u32 kernel_power = get_power (device_param->kernel_power); + const u32 kernel_power = get_power (device_param); uint work = MIN (words_left, kernel_power); @@ -4461,7 +4533,7 @@ static void *thread_calc_stdin (void *p) uint words_cur = 0; - while (words_cur < get_power (device_param->kernel_power)) + while (words_cur < device_param->kernel_power) { char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin); @@ -4495,6 +4567,8 @@ static void *thread_calc_stdin (void *p) continue; } + // hmm that's always the case, or? + if (attack_kern == ATTACK_KERN_STRAIGHT) { if ((line_len < data.pw_min) || (line_len > data.pw_max)) @@ -4511,25 +4585,6 @@ static void *thread_calc_stdin (void *p) continue; } } - else if (attack_kern == ATTACK_KERN_COMBI) - { - // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here - // since we still need to combine the plains - - if (line_len > data.pw_max) - { - hc_thread_mutex_lock (mux_counter); - - for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++) - { - data.words_progress_rejected[salt_pos] += data.combs_cnt; - } - - hc_thread_mutex_unlock (mux_counter); - - continue; - } - } pw_add (device_param, (u8 *) line_buf, line_len); @@ -5314,7 +5369,7 @@ static uint hlfmt_detect (FILE *fp, uint max_check) // wrapper around mymalloc for ADL #if defined(HAVE_HWMON) -void *__stdcall ADL_Main_Memory_Alloc (const int iSize) +void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize) { return mymalloc (iSize); } @@ -5336,8 +5391,6 @@ static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, cons for (uint i = 0; i < digests_cnt; i++) { - if (data.digests_shown[i] == 1) continue; // can happen with potfile - uint *digest_ptr = (uint *) digests_buf_ptr; digests_buf_ptr += dgst_size; @@ -5372,7 +5425,20 @@ static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, cons * main */ -#ifdef _WIN +#ifdef LINUX +int (*clock_gettime_orig) (clockid_t clk_id, struct timespec *tp); + +int clock_gettime (clockid_t clk_id, struct timespec *tp) +{ + int r = clock_gettime_orig (clk_id, tp); + + usleep (NVIDIA_100PERCENTCPU_WORKAROUND); + + return r; +} +#endif + +#ifdef WIN void SetConsoleWindowSize (const int x) { HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE); @@ -5400,7 +5466,11 @@ void SetConsoleWindowSize (const int x) int main (int argc, char **argv) { - #ifdef _WIN + #ifdef LINUX + clock_gettime_orig = dlsym (RTLD_NEXT, "clock_gettime"); + #endif + + #ifdef WIN SetConsoleWindowSize (132); #endif @@ -6041,6 +6111,9 @@ int main (int argc, char **argv) { log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG); log_info (""); + log_info ("Note: Reported benchmark cracking speed = real cracking speed"); + log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b"); + log_info (""); } else { @@ -6077,7 +6150,7 @@ int main (int argc, char **argv) return (-1); } - if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd + if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd { log_error ("ERROR: Invalid hash-type specified"); @@ -6899,7 +6972,10 @@ int main (int argc, char **argv) gpu_temp_disable = 1; #ifdef HAVE_HWMON - powertune_enable = 1; + if (powertune_enable == 1) + { + gpu_temp_disable = 0; + } #endif data.status_timer = status_timer; @@ -10750,6 +10826,26 @@ int main (int argc, char **argv) dgst_pos3 = 3; break; + case 13800: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_INSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_BE + | OPTS_TYPE_PT_UNICODE; + kern_type = KERN_TYPE_WIN8PHONE; + dgst_size = DGST_SIZE_4_8; + parse_func = win8phone_parse_hash; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_PRECOMPUTE_INIT + | OPTI_TYPE_EARLY_SKIP + | OPTI_TYPE_NOT_ITERATED + | OPTI_TYPE_RAW_HASH; + dgst_pos0 = 3; + dgst_pos1 = 7; + dgst_pos2 = 2; + dgst_pos3 = 6; + break; + default: usage_mini_print (PROGNAME); return (-1); } @@ -10876,6 +10972,7 @@ int main (int argc, char **argv) case 13761: esalt_size = sizeof (tc_t); break; case 13762: esalt_size = sizeof (tc_t); break; case 13763: esalt_size = sizeof (tc_t); break; + case 13800: esalt_size = sizeof (win8phone_t); break; } data.esalt_size = esalt_size; @@ -11209,7 +11306,7 @@ int main (int argc, char **argv) break; case 7400: if (pw_max > 16) pw_max = 16; break; - case 7500: if (pw_max > 8) pw_max = 8; + case 7700: if (pw_max > 8) pw_max = 8; break; case 7900: if (pw_max > 48) pw_max = 48; break; @@ -14210,14 +14307,24 @@ int main (int argc, char **argv) const uint platform_devices_id = device_param->platform_devices_id; - if (device_param->device_vendor_id == VENDOR_ID_NV) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - memcpy (&data.hm_device[device_id], &hm_adapters_nvml[platform_devices_id], sizeof (hm_attrs_t)); + data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl; + data.hm_device[device_id].nvapi = 0; + data.hm_device[device_id].nvml = 0; + data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version; + data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported; } - if (device_param->device_vendor_id == VENDOR_ID_AMD) + if (device_param->device_vendor_id == VENDOR_ID_NV) { - memcpy (&data.hm_device[device_id], &hm_adapters_adl[platform_devices_id], sizeof (hm_attrs_t)); + data.hm_device[device_id].adl = 0; + data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi; + data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml; + data.hm_device[device_id].od_version = 0; + data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = 0; } } } @@ -14485,6 +14592,8 @@ int main (int argc, char **argv) device_param->kernel_threads = kernel_threads; + device_param->hardware_power = device_processors * kernel_threads; + /** * create input buffers on device : calculate size of fixed memory buffers */ @@ -14599,7 +14708,7 @@ int main (int argc, char **argv) * some algorithms need a fixed kernel-loops count */ - if (hash_mode == 1500) + if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF) { const u32 kernel_loops_fixed = 1024; @@ -14607,7 +14716,7 @@ int main (int argc, char **argv) device_param->kernel_loops_max = kernel_loops_fixed; } - if (hash_mode == 3000) + if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF) { const u32 kernel_loops_fixed = 1024; @@ -16979,7 +17088,7 @@ int main (int argc, char **argv) data.ms_paused = 0; - data.kernel_power_div = 0; + data.kernel_power_final = 0; data.words_cur = rd->words_cur; @@ -17489,35 +17598,12 @@ int main (int argc, char **argv) } } - data.devices_status = STATUS_RUNNING; - - if (initial_restore_done == 0) - { - if (data.restore_disable == 0) cycle_restore (); - - initial_restore_done = 1; - } - - hc_timer_set (&data.timer_running); - - if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) - { - if ((quiet == 0) && (status == 0) && (benchmark == 0)) - { - if (quiet == 0) fprintf (stdout, "%s", PROMPT); - if (quiet == 0) fflush (stdout); - } - } - else if (wordlist_mode == WL_MODE_STDIN) - { - if (data.quiet == 0) log_info ("Starting attack in stdin mode..."); - if (data.quiet == 0) log_info (""); - } - /** * create autotune threads */ + data.devices_status = STATUS_AUTOTUNE; + hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t)); for (uint device_id = 0; device_id < data.devices_cnt; device_id++) @@ -17533,15 +17619,21 @@ int main (int argc, char **argv) * Inform user about possible slow speeds */ + uint hardware_power_all = 0; + uint kernel_power_all = 0; for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { hc_device_param_t *device_param = &devices_param[device_id]; + hardware_power_all += device_param->hardware_power; + kernel_power_all += device_param->kernel_power; } + data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices + data.kernel_power_all = kernel_power_all; if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) @@ -17564,6 +17656,31 @@ int main (int argc, char **argv) * create cracker threads */ + data.devices_status = STATUS_RUNNING; + + if (initial_restore_done == 0) + { + if (data.restore_disable == 0) cycle_restore (); + + initial_restore_done = 1; + } + + hc_timer_set (&data.timer_running); + + if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) + { + if ((quiet == 0) && (status == 0) && (benchmark == 0)) + { + if (quiet == 0) fprintf (stdout, "%s", PROMPT); + if (quiet == 0) fflush (stdout); + } + } + else if (wordlist_mode == WL_MODE_STDIN) + { + if (data.quiet == 0) log_info ("Starting attack in stdin mode..."); + if (data.quiet == 0) log_info (""); + } + time_t runtime_start; time (&runtime_start);