arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-01-03 12:21:07 +00:00
Code Issues Releases Wiki Activity

Get rid of attack_mode variable in data. context

Browse Source
This commit is contained in:
jsteube 2016-09-22 15:41:59 +02:00
parent 479e93ae7d
commit f1d93d576a
12 changed files with 71 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/autotune.h
View File

@ -6,7 +6,7 @@
#ifndef _AUTOTUNE_H
#define _AUTOTUNE_H
int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig);
int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const user_options_t *user_options);
void *thread_autotune (void *p);

4
include/opencl.h
View File

@ -74,14 +74,14 @@ void writeProgramBin (char *dst, u8 *binary, size_t binary_size);
int gidd_to_pw_t (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const u64 gidd, pw_t *pw);
int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const user_options_t *user_options, hashconfig_t *hashconfig, 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, const uint fast_iteration);
int run_kernel (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration, hashconfig_t *hashconfig);
int run_kernel (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration, hashconfig_t *hashconfig, const user_options_t *user_options);
int run_kernel_mp (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num);
int run_kernel_tm (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param);
int run_kernel_amp (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num);
int run_kernel_memset (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num);
int run_kernel_bzero (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cl_mem buf, const size_t size);
int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const uint pws_cnt);
int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const user_options_t *user_options, const uint pws_cnt);
int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, hashes_t *hashes, const user_options_t *user_options, const user_options_extra_t *user_options_extra, const uint pws_cnt);

2
include/stdout.h
View File

@ -20,6 +20,6 @@
#include <pwd.h>
#endif // _POSIX
void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint pws_cnt);
void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const user_options_t *user_options, const uint pws_cnt);
#endif // _STDOUT_H

1
include/types.h
View File

@ -965,7 +965,6 @@ typedef struct
u32 attack_mode;
u32 attack_kern;
u32 quiet;
u32 force;

40
src/autotune.c
View File

@ -32,7 +32,7 @@
extern hc_global_data_t data;
static double try_run (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const u32 kernel_accel, const u32 kernel_loops)
static double try_run (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const user_options_t *user_options, const u32 kernel_accel, const u32 kernel_loops)
{
const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
@ -42,11 +42,11 @@ static double try_run (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param
if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
run_kernel (KERN_RUN_1, opencl_ctx, device_param, kernel_power_try, true, 0, hashconfig);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, kernel_power_try, true, 0, hashconfig, user_options);
}
else
{
run_kernel (KERN_RUN_2, opencl_ctx, device_param, kernel_power_try, true, 0, hashconfig);
run_kernel (KERN_RUN_2, opencl_ctx, device_param, kernel_power_try, true, 0, hashconfig, user_options);
}
const double exec_ms_prev = get_avg_exec_time (device_param, 1);
@ -54,7 +54,7 @@ static double try_run (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param
return exec_ms_prev;
}
int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig)
int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const user_options_t *user_options)
{
const double target_ms = opencl_ctx->target_ms;
@ -75,10 +75,10 @@ int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
{
if (hashconfig->hash_mode != 2000)
{
try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
}
device_param->kernel_accel = kernel_accel;
@ -146,11 +146,11 @@ int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
{
for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
{
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_min, kernel_loops);
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_min, kernel_loops);
for (int i = 0; i < VERIFIER_CNT; i++)
{
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_min, kernel_loops);
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_min, kernel_loops);
exec_ms = MIN (exec_ms, exec_ms_v);
}
@ -172,11 +172,11 @@ int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
if (kernel_accel_try < kernel_accel_min) continue;
if (kernel_accel_try > kernel_accel_max) break;
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_try, kernel_loops);
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_try, kernel_loops);
for (int i = 0; i < VERIFIER_CNT; i++)
{
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_try, kernel_loops);
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_try, kernel_loops);
exec_ms = MIN (exec_ms, exec_ms_v);
}
@ -195,11 +195,11 @@ int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
// due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
// and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
double exec_ms_pre_final = try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
double exec_ms_pre_final = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
for (int i = 0; i < VERIFIER_CNT; i++)
{
double exec_ms_pre_final_v = try_run (opencl_ctx, device_param, hashconfig, kernel_accel, kernel_loops);
double exec_ms_pre_final_v = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel, kernel_loops);
exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
}
@ -225,11 +225,11 @@ int autotune (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
diff_new = diff;
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_try, kernel_loops_try);
double exec_ms = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_try, kernel_loops_try);
for (int i = 0; i < VERIFIER_CNT; i++)
{
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, kernel_accel_try, kernel_loops_try);
double exec_ms_v = try_run (opencl_ctx, device_param, hashconfig, user_options, kernel_accel_try, kernel_loops_try);
exec_ms = MIN (exec_ms, exec_ms_v);
}
@ -317,11 +317,11 @@ void *thread_autotune (void *p)
if (device_param->skipped) return NULL;
opencl_ctx_t *opencl_ctx = data.opencl_ctx;
user_options_t *user_options = data.user_options;
hashconfig_t *hashconfig = data.hashconfig;
opencl_ctx_t *opencl_ctx = data.opencl_ctx;
hashconfig_t *hashconfig = data.hashconfig;
autotune (opencl_ctx, device_param, hashconfig);
autotune (opencl_ctx, device_param, hashconfig, user_options);
return NULL;
}

8
src/dispatch.c
View File

@ -208,7 +208,7 @@ void *thread_calc_stdin (void *p)
if (pws_cnt)
{
run_copy (opencl_ctx, device_param, hashconfig, pws_cnt);
run_copy (opencl_ctx, device_param, hashconfig, user_options, pws_cnt);
run_cracker (opencl_ctx, device_param, hashconfig, hashes, user_options, user_options_extra, pws_cnt);
@ -248,7 +248,7 @@ void *thread_calc (void *p)
hashes_t *hashes = data.hashes;
opencl_ctx_t *opencl_ctx = data.opencl_ctx;
const uint attack_mode = data.attack_mode;
const uint attack_mode = user_options->attack_mode;
const uint attack_kern = data.attack_kern;
if (attack_mode == ATTACK_MODE_BF)
@ -268,7 +268,7 @@ void *thread_calc (void *p)
if (pws_cnt)
{
run_copy (opencl_ctx, device_param, hashconfig, pws_cnt);
run_copy (opencl_ctx, device_param, hashconfig, user_options, pws_cnt);
run_cracker (opencl_ctx, device_param, hashconfig, hashes, user_options, user_options_extra, pws_cnt);
@ -460,7 +460,7 @@ void *thread_calc (void *p)
if (pws_cnt)
{
run_copy (opencl_ctx, device_param, hashconfig, pws_cnt);
run_copy (opencl_ctx, device_param, hashconfig, user_options, pws_cnt);
run_cracker (opencl_ctx, device_param, hashconfig, hashes, user_options, user_options_extra, pws_cnt);

14
src/hash_management.c
View File

@ -260,7 +260,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
unsigned int plain_len = 0;
if (data.attack_mode == ATTACK_MODE_STRAIGHT)
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
pw_t pw;
@ -308,7 +308,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
if (plain_len > data.pw_max) plain_len = data.pw_max;
}
else if (data.attack_mode == ATTACK_MODE_COMBI)
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
pw_t pw;
@ -346,7 +346,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
if (plain_len > data.pw_max) plain_len = data.pw_max;
}
}
else if (data.attack_mode == ATTACK_MODE_BF)
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
@ -366,7 +366,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
crackpos *= data.bfs_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
else if (data.attack_mode == ATTACK_MODE_HYBRID1)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
pw_t pw;
@ -397,7 +397,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
if (plain_len > data.pw_max) plain_len = data.pw_max;
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
pw_t pw;
@ -431,7 +431,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
}
}
if (data.attack_mode == ATTACK_MODE_BF)
if (user_options->attack_mode == ATTACK_MODE_BF)
{
if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
{
@ -493,7 +493,7 @@ void check_hash (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, cons
if (debugfile_ctx->fp != NULL)
{
// the next check implies that:
// - (data.attack_mode == ATTACK_MODE_STRAIGHT)
// - (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
// - debug_mode > 0
if ((debug_plain_len > 0) || (debug_rule_len > 0))

1
src/hashcat.c
View File

@ -270,7 +270,6 @@ int main (int argc, char **argv)
if (1)
{
data.attack_mode = user_options->attack_mode;
data.force = user_options->force;
data.quiet = user_options->quiet;
data.attack_kern = user_options_extra->attack_kern;

50
src/opencl.c
View File

@ -250,7 +250,7 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, co
if (hashconfig->hash_mode == 2000)
{
process_stdout (opencl_ctx, device_param, pws_cnt);
process_stdout (opencl_ctx, device_param, user_options, pws_cnt);
return 0;
}
@ -280,26 +280,26 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, co
if (highest_pw_len < 16)
{
run_kernel (KERN_RUN_1, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig, user_options);
}
else if (highest_pw_len < 32)
{
run_kernel (KERN_RUN_2, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig);
run_kernel (KERN_RUN_2, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig, user_options);
}
else
{
run_kernel (KERN_RUN_3, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig);
run_kernel (KERN_RUN_3, opencl_ctx, device_param, pws_cnt, true, fast_iteration, hashconfig, user_options);
}
}
else
{
run_kernel_amp (opencl_ctx, device_param, pws_cnt);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig, user_options);
if (opts_type & OPTS_TYPE_HOOK12)
{
run_kernel (KERN_RUN_12, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig);
run_kernel (KERN_RUN_12, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig, user_options);
CL_err = hc_clEnqueueReadBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
@ -335,7 +335,7 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, co
device_param->kernel_params_buf32[28] = loop_pos;
device_param->kernel_params_buf32[29] = loop_left;
run_kernel (KERN_RUN_2, opencl_ctx, device_param, pws_cnt, true, slow_iteration, hashconfig);
run_kernel (KERN_RUN_2, opencl_ctx, device_param, pws_cnt, true, slow_iteration, hashconfig, user_options);
while (opencl_ctx->run_thread_level2 == false) break;
@ -365,7 +365,7 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, co
if (opts_type & OPTS_TYPE_HOOK23)
{
run_kernel (KERN_RUN_23, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig);
run_kernel (KERN_RUN_23, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig, user_options);
CL_err = hc_clEnqueueReadBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
@ -388,13 +388,13 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, co
}
}
run_kernel (KERN_RUN_3, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig);
run_kernel (KERN_RUN_3, opencl_ctx, device_param, pws_cnt, false, 0, hashconfig, user_options);
}
return 0;
}
int run_kernel (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration, hashconfig_t *hashconfig)
int run_kernel (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration, hashconfig_t *hashconfig, const user_options_t *user_options)
{
cl_int CL_err = CL_SUCCESS;
@ -439,7 +439,7 @@ int run_kernel (const uint kern_run, opencl_ctx_t *opencl_ctx, hc_device_param_t
cl_event event;
if ((hashconfig->opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
if ((hashconfig->opts_type & OPTS_TYPE_PT_BITSLICE) && (user_options->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 };
@ -865,7 +865,7 @@ int run_kernel_bzero (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
return run_kernel_memset (opencl_ctx, device_param, buf, 0, size);
}
int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const uint pws_cnt)
int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashconfig_t *hashconfig, const user_options_t *user_options, const uint pws_cnt)
{
cl_int CL_err = CL_SUCCESS;
@ -882,7 +882,7 @@ int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
}
else if (data.attack_kern == ATTACK_KERN_COMBI)
{
if (data.attack_mode == ATTACK_MODE_COMBI)
if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
{
@ -910,7 +910,7 @@ int run_copy (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hashcon
}
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01)
{
@ -1009,7 +1009,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
FILE *combs_fp = device_param->combs_fp;
if (data.attack_mode == ATTACK_MODE_COMBI)
if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
rewind (combs_fp);
}
@ -1065,7 +1065,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
// initialize amplifiers
if (data.attack_mode == ATTACK_MODE_COMBI)
if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
uint i = 0;
@ -1146,7 +1146,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
innerloop_left = i;
}
else if (data.attack_mode == ATTACK_MODE_BF)
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
u64 off = innerloop_pos;
@ -1154,7 +1154,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
run_kernel_mp (KERN_RUN_MP_R, opencl_ctx, device_param, innerloop_left);
}
else if (data.attack_mode == ATTACK_MODE_HYBRID1)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
u64 off = innerloop_pos;
@ -1162,7 +1162,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
run_kernel_mp (KERN_RUN_MP, opencl_ctx, device_param, innerloop_left);
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
u64 off = innerloop_pos;
@ -1173,7 +1173,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
// copy amplifiers
if (data.attack_mode == ATTACK_MODE_STRAIGHT)
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
cl_int CL_err = hc_clEnqueueCopyBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
@ -1184,7 +1184,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
return -1;
}
}
else if (data.attack_mode == ATTACK_MODE_COMBI)
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
cl_int CL_err = hc_clEnqueueWriteBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
@ -1195,7 +1195,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
return -1;
}
}
else if (data.attack_mode == ATTACK_MODE_BF)
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
cl_int CL_err = hc_clEnqueueCopyBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
@ -1206,7 +1206,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
return -1;
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID1)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
cl_int CL_err = hc_clEnqueueCopyBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
@ -1217,7 +1217,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
return -1;
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
cl_int CL_err = hc_clEnqueueCopyBuffer (opencl_ctx->ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
@ -1234,7 +1234,7 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
hc_timer_set (&device_param->timer_speed);
}
int rc = choose_kernel (opencl_ctx, device_param, user_options, hashconfig, hashconfig->attack_exec, data.attack_mode, hashconfig->opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
int rc = choose_kernel (opencl_ctx, device_param, user_options, hashconfig, hashconfig->attack_exec, user_options->attack_mode, hashconfig->opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
if (rc == -1) return -1;

2
src/status.c
View File

@ -436,7 +436,7 @@ void status_display (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig, c
log_info ("Custom.Charset.: -1 %s, -2 %s, -3 %s, -4 %s", custom_charset_1, custom_charset_2, custom_charset_3, custom_charset_4);
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);

12
src/stdout.c
View File

@ -59,7 +59,7 @@ static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
}
}
void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const uint pws_cnt)
void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, const user_options_t *user_options, const uint pws_cnt)
{
out_t out;
@ -93,7 +93,7 @@ void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
if (data.attack_mode == ATTACK_MODE_STRAIGHT)
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
pw_t pw;
@ -120,7 +120,7 @@ void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
}
}
}
else if (data.attack_mode == ATTACK_MODE_COMBI)
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
pw_t pw;
@ -162,7 +162,7 @@ void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
}
}
}
else if (data.attack_mode == ATTACK_MODE_BF)
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
{
@ -186,7 +186,7 @@ void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
}
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID1)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
pw_t pw;
@ -216,7 +216,7 @@ void process_stdout (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
}
}
}
else if (data.attack_mode == ATTACK_MODE_HYBRID2)
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
pw_t pw;

8
src/weak_hash.c
View File

@ -64,11 +64,11 @@ void weak_hash_check (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{
run_kernel (KERN_RUN_1, opencl_ctx, device_param, 1, false, 0, hashconfig);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, 1, false, 0, hashconfig, user_options);
}
else
{
run_kernel (KERN_RUN_1, opencl_ctx, device_param, 1, false, 0, hashconfig);
run_kernel (KERN_RUN_1, opencl_ctx, device_param, 1, false, 0, hashconfig, user_options);
uint loop_step = 16;
@ -83,10 +83,10 @@ void weak_hash_check (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param,
device_param->kernel_params_buf32[28] = loop_pos;
device_param->kernel_params_buf32[29] = loop_left;
run_kernel (KERN_RUN_2, opencl_ctx, device_param, 1, false, 0, hashconfig);
run_kernel (KERN_RUN_2, opencl_ctx, device_param, 1, false, 0, hashconfig, user_options);
}
run_kernel (KERN_RUN_3, opencl_ctx, device_param, 1, false, 0, hashconfig);
run_kernel (KERN_RUN_3, opencl_ctx, device_param, 1, false, 0, hashconfig, user_options);
}
/**