-/**
+ /**
* Authors.....: Jens Steube <jens.steube@gmail.com>
* Gabriele Gristina <matrix@hashcat.net>
* magnum <john.magnum@hushmail.com>
#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
+#define NVIDIA_100PERCENTCPU_WORKAROUND 100
+
#define global_free(attr) \
{ \
myfree ((void *) data.attr); \
" 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",
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;
* result
*/
- check_cracked (device_param, salt_pos);
+ if (data.benchmark == 0)
+ {
+ check_cracked (device_param, salt_pos);
+ }
/**
* progress
//}
}
-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)
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);
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);
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))
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);
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;
}
#endif
+#ifdef _POSIX
+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
+
int main (int argc, char **argv)
{
+ #ifdef _POSIX
+ clock_gettime_orig = dlsym (RTLD_NEXT, "clock_gettime");
+ #endif
+
#ifdef _WIN
SetConsoleWindowSize (132);
#endif
{
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
{
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");
gpu_temp_disable = 1;
#ifdef HAVE_HWMON
- powertune_enable = 1;
+ if (powertune_enable == 1)
+ {
+ gpu_temp_disable = 0;
+ }
#endif
data.status_timer = status_timer;
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);
}
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;
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;
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
*/
* 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;
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;
data.ms_paused = 0;
- data.kernel_power_div = 0;
+ data.kernel_power_final = 0;
data.words_cur = rd->words_cur;
* 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))
projects / hashcat.git / blobdiff