/**
* Authors.....: Jens Steube <jens.steube@gmail.com>
* Gabriele Gristina <matrix@hashcat.net>
+ * magnum <john.magnum@hushmail.com>
*
* License.....: MIT
*/
const uint VERSION_BIN = 210;
const uint RESTORE_MIN = 210;
+double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
+
#define INCR_RULES 10000
#define INCR_SALTS 100000
#define INCR_MASKS 1000
#define MARKOV_DISABLE 0
#define MARKOV_CLASSIC 0
#define BENCHMARK 0
-#define BENCHMARK_MODE 1
+#define BENCHMARK_REPEATS 2
#define RESTORE 0
#define RESTORE_TIMER 60
#define RESTORE_DISABLE 0
#define MAX_DICTSTAT 10000
-#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
+#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
#define global_free(attr) \
{ \
5600,
7300,
7500,
+ 13100,
8300,
11100,
11200,
101,
111,
1711,
- 3000, // broken in osx
+ 3000,
1000,
1100,
2100,
12800,
- 1500, // broken in osx
+ 1500,
12400,
500,
3200,
10410,
10500,
10600,
- 10700, // broken in osx
+ 10700,
9000,
5200,
6800,
" -h, --help Print help",
" --quiet Suppress output",
"",
- "* Benchmark:",
- "",
- " -b, --benchmark Run benchmark",
- " --benchmark-mode=NUM Benchmark-mode, see references below",
- "",
"* Misc:",
"",
" --hex-charset Assume charset is given in hex",
"",
"* Resources:",
"",
+ " -b, --benchmark Run benchmark",
+ " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
" -c, --segment-size=NUM Size in MB to cache from the wordfile",
" --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
" --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
" --opencl-platforms=STR OpenCL platforms to use, separate with comma",
" -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
" --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
- " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
+ " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
" -w, --workload-profile=NUM Enable a specific workload profile, see references below",
- " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
- " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
+ " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
+ " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
" --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
#ifdef HAVE_HWMON
" --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
"",
"* Workload Profile:",
"",
- " 1 = Reduced performance profile (low latency desktop)",
- " 2 = Default performance profile",
- " 3 = Tuned performance profile (high latency desktop)",
- "",
- "* Benchmark Settings:",
- "",
- " 0 = Manual Tuning",
- " 1 = Performance Tuning, default",
+ " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
+ " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
+ " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
"",
"* OpenCL device-types:",
"",
" 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
" 11200 = MySQL Challenge-Response Authentication (SHA1)",
" 11400 = SIP digest authentication (MD5)",
+ " 13100 = Kerberos 5 TGS-REP etype 23",
"",
"[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
"",
* oclHashcat specific functions
*/
+static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
+{
+ int exec_pos = (int) device_param->exec_pos - last_num_entries;
+
+ if (exec_pos < 0) exec_pos += EXEC_CACHE;
+
+ double exec_ms_sum = 0;
+
+ int exec_ms_cnt = 0;
+
+ for (int i = 0; i < last_num_entries; i++)
+ {
+ double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
+
+ if (exec_ms)
+ {
+ exec_ms_sum += exec_ms;
+
+ exec_ms_cnt++;
+ }
+ }
+
+ if (exec_ms_cnt == 0) return 0;
+
+ return exec_ms_sum / exec_ms_cnt;
+}
+
void status_display_automat ()
{
FILE *out = stdout;
if (device_param->skipped) continue;
- double exec_ms_total = 0;
+ double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
- int exec_ms_cnt = 0;
-
- for (int i = 0; i < EXEC_CACHE; i++)
- {
- double exec_ms = device_param->exec_ms[i];
-
- if (exec_ms)
- {
- exec_ms_total += exec_ms;
-
- exec_ms_cnt++;
- }
- }
-
- exec_ms_total /= exec_ms_cnt;
-
- fprintf (out, "%f\t", exec_ms_total);
+ fprintf (out, "%f\t", exec_ms_avg);
}
/**
if (device_param->skipped) continue;
- double exec_ms_total = 0;
-
- int exec_ms_cnt = 0;
-
- for (int i = 0; i < EXEC_CACHE; i++)
- {
- double exec_ms = device_param->exec_ms[i];
-
- if (exec_ms)
- {
- exec_ms_total += exec_ms;
-
- exec_ms_cnt++;
- }
- }
+ double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
- exec_ms_total /= exec_ms_cnt;
-
- exec_all_ms[device_id] = exec_ms_total;
+ exec_all_ms[device_id] = exec_ms_avg;
}
/**
if (device_param->skipped) continue;
- double exec_ms_total = 0;
-
- int exec_ms_cnt = 0;
+ double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
- for (int i = 0; i < EXEC_CACHE; i++)
- {
- double exec_ms = device_param->exec_ms[i];
-
- if (exec_ms)
- {
- exec_ms_total += exec_ms;
-
- exec_ms_cnt++;
- }
- }
-
- exec_ms_total /= exec_ms_cnt;
-
- exec_all_ms[device_id] = exec_ms_total;
+ exec_all_ms[device_id] = exec_ms_avg;
}
for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
}
-static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
+static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
{
if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
}
}
-static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
+static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
{
if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
{
snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
}
-static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
+static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
{
snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
}
unlink (old_hashfile);
}
-static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
+static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
{
- // function called only in case kernel_blocks_all > words_left)
+ // function called only in case kernel_power_all > words_left
- float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
+ float kernel_power_div = (float) (total_left) / kernel_power_all;
- kernel_blocks_div += kernel_blocks_div / 100;
+ kernel_power_div += kernel_power_div / 100;
- u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
+ u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
- while (kernel_blocks_new < total_left)
+ while (kernel_power_new < total_left)
{
- kernel_blocks_div += kernel_blocks_div / 100;
+ kernel_power_div += kernel_power_div / 100;
- kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
+ kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
}
if (data.quiet == 0)
fflush (stdout);
}
- if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
+ if ((kernel_power_all * kernel_power_div) < 8) return 1;
- return kernel_blocks_div;
+ 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)
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]);
- cl_event event;
+ hc_timer_t timer;
+
+ hc_timer_set (&timer);
if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
{
const size_t global_work_size[3] = { num_elements, 32, 1 };
const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
}
else
{
- const size_t global_work_size[3] = { num_elements, 1, 1 };
- const size_t local_work_size[3] = { kernel_threads, 1, 1 };
+ size_t workgroup_size = 0;
- const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
+ hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
- if (rc != CL_SUCCESS)
- {
- const size_t local_work_size_fallback[3] = { 1, 1, 1 };
+ if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
- }
+ const size_t global_work_size[3] = { num_elements, 1, 1 };
+ const size_t local_work_size[3] = { kernel_threads, 1, 1 };
+
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
}
hc_clFlush (data.ocl, device_param->command_queue);
- hc_clWaitForEvents (data.ocl, 1, &event);
+ hc_clFinish (data.ocl, device_param->command_queue);
if (event_update)
{
- cl_ulong time_start;
- cl_ulong time_end;
+ float exec_time;
- hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
- hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
-
- const double exec_time = (time_end - time_start) / 1000000.0;
+ hc_timer_get (timer, exec_time);
uint exec_pos = device_param->exec_pos;
device_param->exec_pos = exec_pos;
}
-
- hc_clReleaseEvent (data.ocl, event);
-
- hc_clFinish (data.ocl, device_param->command_queue);
}
static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
// causes problems with special threads like in bcrypt
// const uint kernel_threads = device_param->kernel_threads;
- const uint kernel_threads = KERNEL_THREADS;
+ uint kernel_threads = KERNEL_THREADS;
while (num_elements % kernel_threads) num_elements++;
break;
}
+ size_t workgroup_size = 0;
+ hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
+ if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
+
const size_t global_work_size[3] = { num_elements, 1, 1 };
const size_t local_work_size[3] = { kernel_threads, 1, 1 };
- const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
-
- if (rc != CL_SUCCESS)
- {
- const size_t local_work_size_fallback[3] = { 1, 1, 1 };
-
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
- }
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
hc_clFlush (data.ocl, device_param->command_queue);
cl_kernel kernel = device_param->kernel_tb;
+ size_t workgroup_size = 0;
+ hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
+ if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
+
const size_t global_work_size[3] = { num_elements, 1, 1 };
const size_t local_work_size[3] = { kernel_threads, 1, 1 };
- const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
-
- if (rc != CL_SUCCESS)
- {
- const size_t local_work_size_fallback[3] = { 1, 1, 1 };
-
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
- }
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
hc_clFlush (data.ocl, device_param->command_queue);
{
const uint num_elements = 1024; // fixed
- const uint kernel_threads = 32;
+ uint kernel_threads = 32;
cl_kernel kernel = device_param->kernel_tm;
+ size_t workgroup_size = 0;
+ hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
+ if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
+
const size_t global_work_size[3] = { num_elements, 1, 1 };
const size_t local_work_size[3] = { kernel_threads, 1, 1 };
- const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
-
- if (rc != CL_SUCCESS)
- {
- const size_t local_work_size_fallback[3] = { 1, 1, 1 };
-
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
- }
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
hc_clFlush (data.ocl, device_param->command_queue);
// causes problems with special threads like in bcrypt
// const uint kernel_threads = device_param->kernel_threads;
- const uint kernel_threads = KERNEL_THREADS;
+ uint kernel_threads = KERNEL_THREADS;
while (num_elements % kernel_threads) num_elements++;
hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
+ size_t workgroup_size = 0;
+ hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
+ if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
+
const size_t global_work_size[3] = { num_elements, 1, 1 };
const size_t local_work_size[3] = { kernel_threads, 1, 1 };
- const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
-
- if (rc != CL_SUCCESS)
- {
- const size_t local_work_size_fallback[3] = { 1, 1, 1 };
-
- hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
- }
+ hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
hc_clFlush (data.ocl, device_param->command_queue);
}
}
+static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
+{
+ if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
+ {
+ if (attack_mode == ATTACK_MODE_BF)
+ {
+ if (opts_type & OPTS_TYPE_PT_BITSLICE)
+ {
+ const uint size_tm = 32 * sizeof (bs_word_t);
+
+ run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
+
+ run_kernel_tm (device_param);
+
+ hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
+ }
+ }
+
+ if (highest_pw_len < 16)
+ {
+ run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
+ }
+ else if (highest_pw_len < 32)
+ {
+ run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
+ }
+ else
+ {
+ run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
+ }
+ }
+ else
+ {
+ run_kernel_amp (device_param, pws_cnt);
+
+ run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
+
+ if (opts_type & OPTS_TYPE_HOOK12)
+ {
+ run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
+ }
+
+ uint iter = salt_buf->salt_iter;
+
+ uint loop_step = device_param->kernel_loops;
+
+ for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
+ {
+ uint loop_left = iter - loop_pos;
+
+ loop_left = MIN (loop_left, loop_step);
+
+ device_param->kernel_params_buf32[25] = loop_pos;
+ device_param->kernel_params_buf32[26] = loop_left;
+
+ run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
+
+ if (data.devices_status == STATUS_CRACKED) break;
+ if (data.devices_status == STATUS_ABORTED) break;
+ if (data.devices_status == STATUS_QUIT) break;
+ }
+
+ if (opts_type & OPTS_TYPE_HOOK23)
+ {
+ run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
+
+ hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
+
+ // do something with data
+
+ hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
+ }
+
+ run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
+ }
+}
+
static int run_rule_engine (const int rule_len, const char *rule_buf)
{
if (rule_len == 0)
}
}
-static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
+static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
+{
+ const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
+
+ device_param->kernel_params_buf32[26] = kernel_loops;
+ device_param->kernel_params_buf32[27] = kernel_loops;
+
+ // init some fake words
+
+ if (data.attack_kern == ATTACK_KERN_BF)
+ {
+ run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
+ run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
+ }
+ else
+ {
+ for (u32 i = 0; i < kernel_power; i++)
+ {
+ device_param->pws_buf[i].pw_len = i & 7;
+ }
+
+ hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
+
+ if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
+ {
+ run_kernel_amp (device_param, kernel_power);
+ }
+ }
+
+ // caching run
+
+ if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
+ {
+ run_kernel (KERN_RUN_1, device_param, kernel_power, false);
+ }
+ else
+ {
+ run_kernel (KERN_RUN_2, device_param, kernel_power, false);
+ }
+
+ // now user repeats
+
+ for (int i = 0; i < repeat; i++)
+ {
+ if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
+ {
+ run_kernel (KERN_RUN_1, device_param, kernel_power, true);
+ }
+ else
+ {
+ run_kernel (KERN_RUN_2, device_param, kernel_power, true);
+ }
+ }
+
+ const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
+
+ // reset fake words
+
+ memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
+
+ hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
+ hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
+
+ return exec_ms_prev;
+}
+
+static void autotune (hc_device_param_t *device_param)
{
- const uint kernel_loops = device_param->kernel_loops;
+ const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
- //only useful in debug
- //if (data.quiet == 0)
- // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
+ const u32 kernel_accel_min = device_param->kernel_accel_min;
+ const u32 kernel_accel_max = device_param->kernel_accel_max;
+ const u32 kernel_loops_min = device_param->kernel_loops_min;
+ const u32 kernel_loops_max = device_param->kernel_loops_max;
+
+ u32 kernel_accel = kernel_accel_min;
+ u32 kernel_loops = kernel_loops_min;
+
+ // steps
+
+ #define STEPS_CNT 10
+
+ #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
+ #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
+
+ u32 steps_accel[STEPS_ACCEL_CNT];
+ u32 steps_loops[STEPS_LOOPS_CNT];
+
+ for (int i = 0; i < STEPS_ACCEL_CNT; i++)
+ {
+ steps_accel[i] = 1 << i;
+ }
+
+ for (int i = 0; i < STEPS_LOOPS_CNT; i++)
+ {
+ steps_loops[i] = 1 << i;
+ }
+
+ steps_accel[STEPS_CNT + 0] = kernel_accel_min;
+ steps_accel[STEPS_CNT + 1] = kernel_accel_max;
+
+ steps_loops[STEPS_CNT + 0] = kernel_loops_min;
+ steps_loops[STEPS_CNT + 1] = kernel_loops_max;
+
+ qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
+ qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
+
+ // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
+
+ u32 kernel_loops_tmp;
+
+ for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
+ {
+ const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
+
+ if (exec_ms < target_ms) break;
+ }
+
+ // kernel-accel
+
+ if (kernel_accel_min < kernel_accel_max)
+ {
+ double e_best = 0;
+
+ for (int i = 0; i < STEPS_ACCEL_CNT; i++)
+ {
+ const u32 kernel_accel_try = steps_accel[i];
+
+ if (kernel_accel_try < kernel_accel_min) continue;
+ if (kernel_accel_try > kernel_accel_max) break;
+
+ const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
+
+ if (exec_ms > target_ms) break;
+
+ const double e = kernel_accel_try / exec_ms;
+
+ if (e > e_best)
+ {
+ kernel_accel = kernel_accel_try;
+
+ e_best = e;
+ }
+ }
+ }
+
+ // kernel-loops final
+
+ if (kernel_loops_min < kernel_loops_max)
+ {
+ double e_best = 0;
+
+ for (int i = 0; i < STEPS_LOOPS_CNT; i++)
+ {
+ const u32 kernel_loops_try = steps_loops[i];
+
+ if (kernel_loops_try < kernel_loops_min) continue;
+ if (kernel_loops_try > kernel_loops_max) break;
+
+ const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
+
+ if (exec_ms > target_ms) break;
+
+ const double e = kernel_loops_try / exec_ms;
+
+ if (e > e_best)
+ {
+ kernel_loops = kernel_loops_try;
+
+ e_best = e;
+ }
+ }
+ }
+
+ // final balance
+
+ const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
+
+ u32 kernel_accel_best = kernel_accel;
+ u32 kernel_loops_best = kernel_loops;
+
+ u32 exec_best = exec_ms;
+
+ // reset
+
+ if (kernel_accel_min < kernel_accel_max)
+ {
+ u32 kernel_accel_try = kernel_accel;
+ u32 kernel_loops_try = kernel_loops;
+
+ for (int i = 0; i < 2; i++)
+ {
+ kernel_accel_try >>= 1;
+ kernel_loops_try <<= 1;
+
+ if (kernel_accel_try < kernel_accel_min) break;
+ if (kernel_loops_try > kernel_loops_max) break;
+
+ const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
+
+ if (exec_ms < exec_best)
+ {
+ kernel_accel_best = kernel_accel_try;
+ kernel_loops_best = kernel_loops_try;
+
+ exec_best = exec_ms;
+ }
+ }
+
+ kernel_accel = kernel_accel_best;
+ kernel_loops = kernel_loops_best;
+ }
+
+ // reset
+
+
+ if (kernel_loops_min < kernel_loops_max)
+ {
+ u32 kernel_accel_try = kernel_accel;
+ u32 kernel_loops_try = kernel_loops;
+
+ for (int i = 0; i < 2; i++)
+ {
+ kernel_accel_try <<= 1;
+ kernel_loops_try >>= 1;
+
+ if (kernel_accel_try > kernel_accel_max) break;
+ if (kernel_loops_try < kernel_loops_min) break;
+
+ const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
+
+ if (exec_ms < exec_best)
+ {
+ kernel_accel_best = kernel_accel_try;
+ kernel_loops_best = kernel_loops_try;
+
+ exec_best = exec_ms;
+ }
+ }
+
+ kernel_accel = kernel_accel_best;
+ kernel_loops = kernel_loops_best;
+ }
+
+ // reset timer
+
+ device_param->exec_pos = 0;
+
+ memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
+
+ // store
+
+ device_param->kernel_loops = kernel_loops;
+ device_param->kernel_accel = kernel_accel;
+
+ const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
+
+ device_param->kernel_power = kernel_power;
+
+ log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
+ log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
+ log_info ("");
+}
+
+static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
+{
// init speed timer
uint speed_pos = device_param->speed_pos;
uint innerloop_step = 0;
uint innerloop_cnt = 0;
- if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
+ if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
else innerloop_step = 1;
if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
device_param->kernel_params_buf32[27] = innerloop_left;
- if (innerloop_left == 0) continue;
+ // i think we can get rid of this
+ if (innerloop_left == 0)
+ {
+ puts ("bug, how should this happen????\n");
+
+ continue;
+ }
// initialize amplifiers
hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
}
- if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
- {
- if (data.attack_mode == ATTACK_MODE_BF)
- {
- if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
- {
- const uint size_tm = 32 * sizeof (bs_word_t);
-
- run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
-
- run_kernel_tm (device_param);
-
- hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
- }
- }
+ choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
- if (highest_pw_len < 16)
- {
- run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
- }
- else if (highest_pw_len < 32)
- {
- run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
- }
- else
- {
- run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
- }
- }
- else
+ if (data.benchmark == 1)
{
- run_kernel_amp (device_param, pws_cnt);
-
- run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
-
- if (data.opts_type & OPTS_TYPE_HOOK12)
- {
- run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
- }
-
- uint iter = salt_buf->salt_iter;
-
- for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
- {
- uint loop_left = iter - loop_pos;
-
- loop_left = MIN (loop_left, kernel_loops);
-
- device_param->kernel_params_buf32[25] = loop_pos;
- device_param->kernel_params_buf32[26] = loop_left;
-
- run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
-
- if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
-
- if (data.devices_status == STATUS_CRACKED) break;
- if (data.devices_status == STATUS_ABORTED) break;
- if (data.devices_status == STATUS_QUIT) break;
- }
-
- if (data.opts_type & OPTS_TYPE_HOOK23)
+ for (u32 i = 0; i < data.benchmark_repeats; i++)
{
- run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
-
- hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
-
- // do something with data
-
- hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
+ choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
}
-
- run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
}
if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
+ if (data.benchmark == 1)
+ {
+ perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
+ }
+
hc_thread_mutex_lock (mux_counter);
data.words_progress_done[salt_pos] += perf_sum_all;
{
speed_pos = 0;
}
+
+ /**
+ * benchmark
+ */
+
+ if (data.benchmark == 1) break;
}
}
const u64 words_left = words_base - words_cur;
- if (data.kernel_blocks_all > words_left)
+ if (data.kernel_power_all > words_left)
{
- if (data.kernel_blocks_div == 0)
+ if (data.kernel_power_div == 0)
{
- data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
+ data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
}
}
- if (data.kernel_blocks_div)
+ if (data.kernel_power_div)
{
- if (device_param->kernel_blocks == device_param->kernel_blocks_user)
+ if (device_param->kernel_power == device_param->kernel_power_user)
{
- const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
- const u32 kernel_power_new = kernel_blocks_new;
+ const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
- if (kernel_blocks_new < device_param->kernel_blocks)
+ if (kernel_power_new < device_param->kernel_power)
{
- device_param->kernel_blocks = kernel_blocks_new;
- device_param->kernel_power = kernel_power_new;
+ device_param->kernel_power = kernel_power_new;
}
}
}
- const uint kernel_blocks = device_param->kernel_blocks;
+ const uint kernel_power = device_param->kernel_power;
- uint work = MIN (words_left, kernel_blocks);
+ uint work = MIN (words_left, kernel_power);
work = MIN (work, max);
if (device_param->skipped) return NULL;
+ autotune (device_param);
+
const uint attack_kern = data.attack_kern;
- const uint kernel_blocks = device_param->kernel_blocks;
+ const uint kernel_power = device_param->kernel_power;
while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
{
uint words_cur = 0;
- while (words_cur < kernel_blocks)
+ while (words_cur < kernel_power)
{
char buf[BUFSIZ] = { 0 };
}
}
+ device_param->kernel_accel = 0;
+ device_param->kernel_loops = 0;
+
return NULL;
}
if (device_param->skipped) return NULL;
+ autotune (device_param);
+
const uint attack_mode = data.attack_mode;
const uint attack_kern = data.attack_kern;
if (data.devices_status == STATUS_QUIT) break;
if (data.devices_status == STATUS_BYPASS) break;
+ if (data.benchmark == 1) break;
+
device_param->words_done = words_fin;
}
}
fclose (fd);
}
+ device_param->kernel_accel = 0;
+ device_param->kernel_loops = 0;
+
return NULL;
}
exit (-1);
}
- const uint kernel_loops = device_param->kernel_loops;
-
salt_t *salt_buf = &data.salts_buf[salt_pos];
device_param->kernel_params_buf32[24] = salt_pos;
{
run_kernel (KERN_RUN_1, device_param, 1, false);
+ uint loop_step = 16;
+
const uint iter = salt_buf->salt_iter;
- for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
+ for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
{
uint loop_left = iter - loop_pos;
- loop_left = MIN (loop_left, kernel_loops);
+ loop_left = MIN (loop_left, loop_step);
device_param->kernel_params_buf32[25] = loop_pos;
device_param->kernel_params_buf32[26] = loop_left;
uint version = VERSION;
uint quiet = QUIET;
uint benchmark = BENCHMARK;
- uint benchmark_mode = BENCHMARK_MODE;
+ uint benchmark_repeats = BENCHMARK_REPEATS;
uint show = SHOW;
uint left = LEFT;
uint username = USERNAME;
#define IDX_FORCE 0xff08
#define IDX_RUNTIME 0xff09
#define IDX_BENCHMARK 'b'
- #define IDX_BENCHMARK_MODE 0xff32
+ #define IDX_BENCHMARK_REPEATS 0xff78
#define IDX_HASH_MODE 'm'
#define IDX_ATTACK_MODE 'a'
#define IDX_RP_FILE 'r'
{"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
{"force", no_argument, 0, IDX_FORCE},
{"benchmark", no_argument, 0, IDX_BENCHMARK},
- {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
+ {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
{"restore", no_argument, 0, IDX_RESTORE},
{"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
{"status", no_argument, 0, IDX_STATUS},
#endif
}
- uint hash_mode_chgd = 0;
- uint runtime_chgd = 0;
- uint kernel_loops_chgd = 0;
- uint kernel_accel_chgd = 0;
- uint attack_mode_chgd = 0;
- uint outfile_format_chgd = 0;
- uint rp_gen_seed_chgd = 0;
- uint remove_timer_chgd = 0;
- uint increment_min_chgd = 0;
- uint increment_max_chgd = 0;
+ uint hash_mode_chgd = 0;
+ uint runtime_chgd = 0;
+ uint kernel_loops_chgd = 0;
+ uint kernel_accel_chgd = 0;
+ uint attack_mode_chgd = 0;
+ uint outfile_format_chgd = 0;
+ uint rp_gen_seed_chgd = 0;
+ uint remove_timer_chgd = 0;
+ uint increment_min_chgd = 0;
+ uint increment_max_chgd = 0;
+ uint workload_profile_chgd = 0;
+ uint opencl_vector_width_chgd = 0;
+
#if defined(HAVE_HWMON) && defined(HAVE_ADL)
- uint gpu_temp_retain_chgd = 0;
- uint gpu_temp_abort_chgd = 0;
+ uint gpu_temp_retain_chgd = 0;
+ uint gpu_temp_abort_chgd = 0;
#endif
optind = 1;
case IDX_LIMIT: limit = atoll (optarg); break;
case IDX_KEYSPACE: keyspace = 1; break;
case IDX_BENCHMARK: benchmark = 1; break;
- case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
+ case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
case IDX_RESTORE: break;
case IDX_RESTORE_DISABLE: restore_disable = 1; break;
case IDX_STATUS: status = 1; break;
case IDX_OPENCL_DEVICE_TYPES:
opencl_device_types = optarg; break;
case IDX_OPENCL_VECTOR_WIDTH:
- opencl_vector_width = atoi (optarg); break;
- case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
- case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
- kernel_accel_chgd = 1; break;
- case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
- kernel_loops_chgd = 1; break;
+ opencl_vector_width = atoi (optarg);
+ opencl_vector_width_chgd = 1; break;
+ case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
+ workload_profile_chgd = 1; break;
+ case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
+ kernel_accel_chgd = 1; break;
+ case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
+ kernel_loops_chgd = 1; break;
case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
#ifdef HAVE_HWMON
case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
return (-1);
}
- if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
+ if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
{
log_error ("ERROR: Invalid hash-type specified");
if (kernel_accel_chgd == 1)
{
- if (workload_profile != WORKLOAD_PROFILE)
- {
- log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
-
- return (-1);
- }
-
if (kernel_accel < 1)
{
log_error ("ERROR: Invalid kernel-accel specified");
if (kernel_loops_chgd == 1)
{
- if (workload_profile != WORKLOAD_PROFILE)
- {
- log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
-
- return (-1);
- }
-
if (kernel_loops < 1)
{
log_error ("ERROR: Invalid kernel-loops specified");
}
}
- if (benchmark == 1)
- {
- if (workload_profile != WORKLOAD_PROFILE)
- {
- log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
-
- return (-1);
- }
- }
-
if ((workload_profile < 1) || (workload_profile > 3))
{
log_error ("ERROR: workload-profile %i not available", workload_profile);
return (-1);
}
- if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
+ if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
{
log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
return (-1);
}
}
-
- if (benchmark_mode == 0)
- {
- // nothing to do
- }
- else if (benchmark_mode == 1)
- {
- if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
- {
- log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
-
- return (-1);
- }
- }
- else
- {
- log_error ("ERROR: Benchmark-mode must be 0 or 1");
-
- return (-1);
- }
}
if (skip != 0 && limit != 0)
data.rp_gen_seed = rp_gen_seed;
data.force = force;
data.benchmark = benchmark;
+ data.benchmark_repeats = benchmark_repeats;
data.skip = skip;
data.limit = limit;
#if defined(HAVE_HWMON) && defined(HAVE_ADL)
data.logfile_disable = logfile_disable;
data.truecrypt_keyfiles = truecrypt_keyfiles;
data.scrypt_tmto = scrypt_tmto;
+ data.workload_profile = workload_profile;
/**
* cpu affinity
logfile_top_uint (attack_mode);
logfile_top_uint (attack_kern);
logfile_top_uint (benchmark);
- logfile_top_uint (benchmark_mode);
+ logfile_top_uint (benchmark_repeats);
logfile_top_uint (bitmap_min);
logfile_top_uint (bitmap_max);
logfile_top_uint (debug_mode);
* disable useless stuff for benchmark
*/
- restore_timer = 0;
- status_timer = 0;
- restore_disable = 1;
- potfile_disable = 1;
- weak_hash_threshold = 0;
-
- data.restore_timer = restore_timer;
- data.status_timer = status_timer;
- data.restore_disable = restore_disable;
+ status_timer = 0;
+ restore_timer = 0;
+ restore_disable = 1;
+ potfile_disable = 1;
+ weak_hash_threshold = 0;
+ gpu_temp_disable = 1;
- if (benchmark_mode == 1)
- {
- markov_disable = 1;
-
- workload_profile = 3;
- }
+ data.status_timer = status_timer;
+ data.restore_timer = restore_timer;
+ data.restore_disable = restore_disable;
/**
* force attack mode to be bruteforce
attack_mode = ATTACK_MODE_BF;
attack_kern = ATTACK_KERN_BF;
- if (runtime_chgd == 0)
+ if (workload_profile_chgd == 0)
{
- runtime = 8;
-
- if (benchmark_mode == 1) runtime = 17;
+ workload_profile = 3;
- data.runtime = runtime;
+ data.workload_profile = workload_profile;
}
}
dgst_pos3 = 3;
break;
+ case 13100: hash_type = HASH_TYPE_KRB5TGS;
+ salt_type = SALT_TYPE_EMBEDDED;
+ attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
+ opts_type = OPTS_TYPE_PT_GENERATE_LE;
+ kern_type = KERN_TYPE_KRB5TGS;
+ dgst_size = DGST_SIZE_4_4;
+ parse_func = krb5tgs_parse_hash;
+ sort_by_digest = sort_by_digest_4_4;
+ opti_type = OPTI_TYPE_ZERO_BYTE
+ | OPTI_TYPE_NOT_ITERATED;
+ dgst_pos0 = 0;
+ dgst_pos1 = 1;
+ dgst_pos2 = 2;
+ dgst_pos3 = 3;
+ break;
+
default: usage_mini_print (PROGNAME); return (-1);
}
case 5400: esalt_size = sizeof (ikepsk_t); break;
case 5500: esalt_size = sizeof (netntlm_t); break;
case 5600: esalt_size = sizeof (netntlm_t); break;
- case 6211:
- case 6212:
- case 6213:
- case 6221:
- case 6222:
- case 6223:
- case 6231:
- case 6232:
- case 6233:
- case 6241:
- case 6242:
+ case 6211: esalt_size = sizeof (tc_t); break;
+ case 6212: esalt_size = sizeof (tc_t); break;
+ case 6213: esalt_size = sizeof (tc_t); break;
+ case 6221: esalt_size = sizeof (tc_t); break;
+ case 6222: esalt_size = sizeof (tc_t); break;
+ case 6223: esalt_size = sizeof (tc_t); break;
+ case 6231: esalt_size = sizeof (tc_t); break;
+ case 6232: esalt_size = sizeof (tc_t); break;
+ case 6233: esalt_size = sizeof (tc_t); break;
+ case 6241: esalt_size = sizeof (tc_t); break;
+ case 6242: esalt_size = sizeof (tc_t); break;
case 6243: esalt_size = sizeof (tc_t); break;
case 6600: esalt_size = sizeof (agilekey_t); break;
case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
case 13000: esalt_size = sizeof (rar5_t); break;
+ case 13100: esalt_size = sizeof (krb5tgs_t); break;
}
data.esalt_size = esalt_size;
break;
case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
break;
- case 6211:
- case 6212:
- case 6213:
- case 6221:
- case 6222:
- case 6223:
- case 6231:
- case 6232:
- case 6233:
- case 6241:
- case 6242:
+ case 6211: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6212: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6213: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6221: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6222: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6223: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6231: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6232: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6233: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6241: data.hashfile = mystrdup ("hashcat.tc");
+ break;
+ case 6242: data.hashfile = mystrdup ("hashcat.tc");
+ break;
case 6243: data.hashfile = mystrdup ("hashcat.tc");
break;
case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
break;
case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
break;
- case 6211:
- case 6212:
+ case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
+ break;
+ case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
+ break;
case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
break;
- case 6221:
- case 6222:
+ case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
+ case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
break;
- case 6231:
- case 6232:
+ case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
+ case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
break;
- case 6241:
- case 6242:
+ case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
+ case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
+ break;
case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
break;
case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
// tuning db
- tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
+ tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
// device_version
cl_uint vector_width;
- if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
+ if (opencl_vector_width_chgd == 0)
{
- if (tuningdb_entry->vector_width == -1)
+ if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
{
if (opti_type & OPTI_TYPE_USES_BITS_64)
{
- hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
+ hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
}
else
{
- hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
+ hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
}
}
else
vector_width = opencl_vector_width;
}
- if (vector_width > 8) vector_width = 8;
+ if (vector_width > 16) vector_width = 16;
device_param->vector_width = vector_width;
}
/**
- * kernel accel and loops auto adjustment
+ * kernel accel and loops tuning db adjustment
*/
- uint _kernel_accel = kernel_accel;
- uint _kernel_loops = kernel_loops;
+ device_param->kernel_accel_min = 1;
+ device_param->kernel_accel_max = 1024;
- tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
+ device_param->kernel_loops_min = 1;
+ device_param->kernel_loops_max = 1024;
- if (kernel_accel_chgd == 0)
- {
- _kernel_accel = tuningdb_entry->kernel_accel;
- }
+ tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
- if (kernel_loops_chgd == 0)
+ if (tuningdb_entry)
{
- _kernel_loops = tuningdb_entry->kernel_loops;
- }
+ u32 _kernel_accel = tuningdb_entry->kernel_accel;
+ u32 _kernel_loops = tuningdb_entry->kernel_loops;
- if (workload_profile == 1)
- {
- _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
- }
- else if (workload_profile == 2)
- {
- _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
+ if (_kernel_accel)
+ {
+ device_param->kernel_accel_min = _kernel_accel;
+ device_param->kernel_accel_max = _kernel_accel;
+ }
+
+ if (_kernel_loops)
+ {
+ if (workload_profile == 1)
+ {
+ _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
+ }
+ else if (workload_profile == 2)
+ {
+ _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
+ }
+
+ device_param->kernel_loops_min = _kernel_loops;
+ device_param->kernel_loops_max = _kernel_loops;
+ }
}
- /**
- * there's a few algorithm that force a fixed kernel_loop count
- */
+ // commandline parameters overwrite tuningdb entries
- if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
+ if (kernel_accel)
{
- _kernel_loops = 1024;
+ device_param->kernel_accel_min = kernel_accel;
+ device_param->kernel_accel_max = kernel_accel;
}
- if (hash_mode == 12500)
+ if (kernel_loops)
{
- _kernel_loops = ROUNDS_RAR3 / 16;
+ device_param->kernel_loops_min = kernel_loops;
+ device_param->kernel_loops_max = kernel_loops;
}
- device_param->kernel_accel = _kernel_accel;
- device_param->kernel_loops = _kernel_loops;
+ /**
+ * activate device
+ */
devices_active++;
}
#endif // HAVE_ADK
#endif // HAVE_HWMON
- #ifdef OSX
- if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
- {
- if (force == 0)
- {
- log_info ("");
- log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
- log_info ("You can use --force to override this but do not post error reports if you do so");
- log_info ("");
-
- continue;
- }
- }
- #endif
-
#ifdef DEBUG
if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
#endif
- uint kernel_blocks_all = 0;
+ uint kernel_power_all = 0;
for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
{
* device properties
*/
- char *device_name_chksum = device_param->device_name_chksum;
-
- uint device_processors = device_param->device_processors;
-
- uint device_processor_cores = device_param->device_processor_cores;
-
- uint kernel_accel = device_param->kernel_accel;
+ 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
device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
/**
- * create input buffers on device
+ * create input buffers on device : calculate size of fixed memory buffers
*/
- uint kernel_threads = KERNEL_THREADS;
-
- // bcrypt
- if (hash_mode == 3200) kernel_threads = 8;
- if (hash_mode == 9000) kernel_threads = 8;
-
- uint kernel_power = 1;
- uint kernel_blocks = 1;
-
- uint size_pws = 4;
- uint size_tmps = 4;
- uint size_hooks = 4;
-
- // find out if we would request too much memory on memory blocks which are based on kernel_accel
-
- while (kernel_accel)
- {
- kernel_power = device_processors * kernel_threads * kernel_accel;
- kernel_blocks = kernel_power;
-
- // size_pws
-
- size_pws = kernel_blocks * sizeof (pw_t);
-
- // size_tmps
-
- switch (hash_mode)
- {
- case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
- case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
- case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
- case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
- case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
- case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
- case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
- case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
- case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
- case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
- case 6211:
- case 6212:
- case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
- case 6221:
- case 6222:
- case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
- case 6231:
- case 6232:
- case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
- case 6241:
- case 6242:
- case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
- case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
- case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
- case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
- case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
- case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
- case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
- case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
- case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
- case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
- case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
- case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
- case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
- case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
- case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
- case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
- case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
- case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
- case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
- case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
- case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
- case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
- case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
- case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
- case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
- case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
- case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
- case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
- case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
- case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
- case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
- case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
- case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
- case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
- case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
- };
-
- // size_hooks
-
- if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
- {
- // none yet
- }
-
- // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
- // if not, decrease amplifier and try again
-
- if (size_pws > device_param->device_maxmem_alloc)
- {
- kernel_accel--;
-
- continue;
- }
-
- if (size_tmps > device_param->device_maxmem_alloc)
- {
- kernel_accel--;
-
- continue;
- }
-
- if (size_hooks > device_param->device_maxmem_alloc)
- {
- kernel_accel--;
-
- continue;
- }
-
- if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
- {
- kernel_accel--;
-
- continue;
- }
-
- break;
- }
-
- if (kernel_accel == 0)
- {
- log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
-
- return -1;
- }
-
- device_param->kernel_threads = kernel_threads;
- device_param->kernel_power_user = kernel_power;
- device_param->kernel_blocks_user = kernel_blocks;
-
- kernel_blocks_all += kernel_blocks;
-
- device_param->size_pws = size_pws;
- device_param->size_tmps = size_tmps;
- device_param->size_hooks = size_hooks;
-
- // we can optimize some stuff here...
-
uint size_root_css = SP_PW_MAX * sizeof (cs_t);
uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
uint size_results = KERNEL_THREADS * sizeof (uint);
- device_param->size_results = size_results;
+ device_param->size_results = size_results;
uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
uint size_bfs = KERNEL_BFS * sizeof (bf_t);
uint size_tm = 32 * sizeof (bs_word_t);
- // scrypt stuff
+ // scryptV stuff
u64 size_scryptV = 1;
if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
}
+ /**
+ * create input buffers on device : calculate size of dynamic size memory buffers
+ */
+
+ uint kernel_threads = KERNEL_THREADS;
+
+ // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
+
+ if (hash_mode == 3200) kernel_threads = 8;
+ if (hash_mode == 9000) kernel_threads = 8;
+
+ /**
+ * some algorithms need a fixed kernel-loops count
+ */
+
+ if (hash_mode == 1500)
+ {
+ const u32 kernel_loops_fixed = 1024;
+
+ device_param->kernel_loops_min = kernel_loops_fixed;
+ device_param->kernel_loops_max = kernel_loops_fixed;
+ }
+
+ if (hash_mode == 3000)
+ {
+ const u32 kernel_loops_fixed = 1024;
+
+ device_param->kernel_loops_min = kernel_loops_fixed;
+ device_param->kernel_loops_max = kernel_loops_fixed;
+ }
+
+ if (hash_mode == 8900)
+ {
+ const u32 kernel_loops_fixed = 1;
+
+ device_param->kernel_loops_min = kernel_loops_fixed;
+ device_param->kernel_loops_max = kernel_loops_fixed;
+ }
+
+ if (hash_mode == 9300)
+ {
+ const u32 kernel_loops_fixed = 1;
+
+ device_param->kernel_loops_min = kernel_loops_fixed;
+ device_param->kernel_loops_max = kernel_loops_fixed;
+ }
+
+ if (hash_mode == 12500)
+ {
+ const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
+
+ device_param->kernel_loops_min = kernel_loops_fixed;
+ device_param->kernel_loops_max = kernel_loops_fixed;
+ }
+
+ /**
+ * some algorithms have a maximum kernel-loops count
+ */
+
+ if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
+ {
+ if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
+ {
+ device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
+ }
+ }
+
+ /**
+ * some algorithms need a special kernel-accel
+ */
+
+ if (hash_mode == 8900)
+ {
+ device_param->kernel_accel_min = 1;
+ device_param->kernel_accel_max = 64;
+ }
+
+ if (hash_mode == 9300)
+ {
+ device_param->kernel_accel_min = 1;
+ device_param->kernel_accel_max = 64;
+ }
+
+ u32 kernel_accel_min = device_param->kernel_accel_min;
+ u32 kernel_accel_max = device_param->kernel_accel_max;
+
+ // find out if we would request too much memory on memory blocks which are based on kernel_accel
+
+ uint size_pws = 4;
+ uint size_tmps = 4;
+ uint size_hooks = 4;
+
+ while (kernel_accel_max >= kernel_accel_min)
+ {
+ uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
+
+ // size_pws
+
+ size_pws = kernel_power_max * sizeof (pw_t);
+
+ // size_tmps
+
+ switch (hash_mode)
+ {
+ case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
+ case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
+ case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
+ case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
+ case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
+ case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
+ case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
+ case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
+ case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
+ case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
+ case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
+ case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
+ case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
+ case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
+ case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
+ case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
+ case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
+ case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
+ case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
+ case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
+ case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
+ case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
+ case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
+ 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 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 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;
+ case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
+ case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
+ case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
+ case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
+ case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
+ case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
+ case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
+ case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
+ case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
+ case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
+ case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
+ case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
+ case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
+ case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
+ case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
+ case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
+ case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
+ case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
+ case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
+ };
+
+ // size_hooks
+
+ if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
+ {
+ // none yet
+ }
+
+ // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
+ // if not, decrease amplifier and try again
+
+ int skip = 0;
+
+ if (size_pws > device_param->device_maxmem_alloc) skip = 1;
+ if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
+ if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
+
+ if (( bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + bitmap_size
+ + size_bfs
+ + size_combs
+ + size_digests
+ + size_esalts
+ + size_hooks
+ + size_markov_css
+ + size_plains
+ + size_pws
+ + size_results
+ + size_root_css
+ + size_rules
+ + size_rules_c
+ + size_salts
+ + size_scryptV
+ + size_shown
+ + size_tm
+ + size_tmps) > device_param->device_global_mem) skip = 1;
+
+ if (skip == 1)
+ {
+ kernel_accel_max--;
+
+ continue;
+ }
+
+ break;
+ }
+
+ /*
+ if (kernel_accel_max == 0)
+ {
+ log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
+
+ return -1;
+ }
+ */
+
+ device_param->kernel_accel_min = kernel_accel_min;
+ device_param->kernel_accel_max = kernel_accel_max;
+
+ /*
+ if (kernel_accel_max < kernel_accel)
+ {
+ if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
+
+ device_param->kernel_accel = kernel_accel_max;
+ }
+ */
+
+ device_param->size_pws = size_pws;
+ device_param->size_tmps = size_tmps;
+ device_param->size_hooks = size_hooks;
+
+ // do not confuse kernel_accel_max with kernel_accel here
+
+ const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
+
+ device_param->kernel_threads = kernel_threads;
+ device_param->kernel_power_user = kernel_power;
+
+ kernel_power_all += kernel_power;
+
/**
* default building options
*/
#endif // HAVE_HWMON && HAVE_ADL
}
- data.kernel_blocks_all = kernel_blocks_all;
+ data.kernel_power_all = kernel_power_all;
if (data.quiet == 0) log_info ("");
char *hash_type = strhashtype (data.hash_mode); // not a bug
log_info ("Hashtype: %s", hash_type);
- //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
log_info ("");
}
memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
- device_param->kernel_power = device_param->kernel_power_user;
- device_param->kernel_blocks = device_param->kernel_blocks_user;
+ device_param->kernel_power = device_param->kernel_power_user;
device_param->outerloop_pos = 0;
device_param->outerloop_left = 0;
device_param->words_done = 0;
}
- data.kernel_blocks_div = 0;
+ data.kernel_power_div = 0;
// figure out some workload
if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
{
- if (data.words_base < kernel_blocks_all)
+ if (data.words_base < kernel_power_all)
{
if (quiet == 0)
{
projects / hashcat.git / blobdiff