static void init(struct fmt_main *self)
{
host_pass = calloc(KEYS_PER_CRYPT, sizeof(pwsafe_pass));
host_hash = calloc(KEYS_PER_CRYPT, sizeof(pwsafe_hash));
host_salt = calloc(1, sizeof(pwsafe_salt));
opencl_init("$JOHN/pwsafe_kernel.cl", ocl_gpu_id, platform_id);
///Alocate memory on the GPU
mem_salt =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, saltsize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code, "Error while allocating memory for salt");
mem_in =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code, "Error while allocating memory for passwords");
mem_out =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code, "Error while allocating memory for hashes");
///Assign kernel parameters
crypt_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code, "Error while creating kernel");
clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in);
clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out);
clSetKernelArg(crypt_kernel, 2, sizeof(mem_salt), &mem_salt);
opencl_find_best_workgroup(self);
//local_work_size=256;
atexit(release_all);
}
static void init(struct fmt_main *self) {
char *kpc;
global_work_size = MAX_KEYS_PER_CRYPT;
opencl_init("$JOHN/md4_kernel.cl", ocl_gpu_id, platform_id);
crypt_kernel = clCreateKernel(program[ocl_gpu_id], "md4", &ret_code);
HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?");
if( ((kpc = getenv("LWS")) == NULL) || (atoi(kpc) == 0)) {
create_clobj(MD4_NUM_KEYS);
opencl_find_best_workgroup(self);
release_clobj();
}else {
local_work_size = atoi(kpc);
}
if( (kpc = getenv("GWS")) == NULL){
max_keys_per_crypt = MD4_NUM_KEYS;
create_clobj(MD4_NUM_KEYS);
} else {
if (atoi(kpc) == 0){
//user chose to die of boredom
max_keys_per_crypt = MD4_NUM_KEYS;
create_clobj(MD4_NUM_KEYS);
find_best_kpc();
} else {
max_keys_per_crypt = atoi(kpc);
create_clobj(max_keys_per_crypt);
}
}
fprintf(stderr, "Local work size (LWS) %d, Global work size (GWS) %d\n",(int)local_work_size, max_keys_per_crypt);
self->params.max_keys_per_crypt = max_keys_per_crypt;
}
static void init(struct fmt_main *self)
{
char *temp;
if ((temp = getenv("LWS")))
local_work_size = atoi(temp);
else
local_work_size = cpu(device_info[ocl_gpu_id]) ? 1 : 64;
if ((temp = getenv("GWS")))
global_work_size = atoi(temp);
else
global_work_size = MAX_KEYS_PER_CRYPT;
opencl_init("$JOHN/kernels/sha512_kernel.cl", ocl_gpu_id);
gkey = mem_calloc(global_work_size * sizeof(sha512_key));
ghash = mem_calloc(global_work_size * sizeof(sha512_hash));
///Allocate memory on the GPU
mem_in =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for passwords");
mem_out =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for hashes");
mem_binary =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, sizeof(uint64_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for binary");
mem_cmp =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, sizeof(uint32_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for cmp_all result");
///Assign crypt kernel parameters
crypt_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating crypt_kernel");
clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in);
clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out);
///Assign cmp kernel parameters
cmp_kernel = clCreateKernel(program[ocl_gpu_id], CMP_KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating cmp_kernel");
clSetKernelArg(cmp_kernel, 0, sizeof(mem_binary), &mem_binary);
clSetKernelArg(cmp_kernel, 1, sizeof(mem_out), &mem_out);
clSetKernelArg(cmp_kernel, 2, sizeof(mem_cmp), &mem_cmp);
self->params.max_keys_per_crypt = global_work_size;
if (!local_work_size)
opencl_find_best_workgroup(self);
self->params.min_keys_per_crypt = local_work_size;
if (options.verbosity > 2)
fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n",(int)local_work_size, (int)global_work_size);
}
static void init(struct fmt_main *self)
{
cl_int cl_error;
global_work_size = MAX_KEYS_PER_CRYPT;
inbuffer =
(zip_password *) malloc(sizeof(zip_password) *
MAX_KEYS_PER_CRYPT);
outbuffer =
(zip_hash *) malloc(sizeof(zip_hash) * MAX_KEYS_PER_CRYPT);
/* Zeroize the lengths in case crypt_all() is called with some keys still
* not set. This may happen during self-tests. */
{
int i;
for (i = 0; i < MAX_KEYS_PER_CRYPT; i++)
inbuffer[i].length = 0;
}
cracked = mem_calloc_tiny(sizeof(*cracked) *
KEYS_PER_CRYPT, MEM_ALIGN_WORD);
//listOpenCLdevices();
opencl_init("$JOHN/zip_kernel.cl", ocl_gpu_id, platform_id);
/// Alocate memory
mem_in =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem in");
mem_setting =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, settingsize,
NULL, &cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem setting");
mem_out =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem out");
crypt_kernel = clCreateKernel(program[ocl_gpu_id], "zip", &cl_error);
HANDLE_CLERROR(cl_error, "Error creating kernel");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 0, sizeof(mem_in),
&mem_in), "Error while setting mem_in kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 1, sizeof(mem_out),
&mem_out), "Error while setting mem_out kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 2, sizeof(mem_setting),
&mem_setting), "Error while setting mem_salt kernel argument");
opencl_find_best_workgroup(self);
atexit(release_all);
}
static void init(struct fmt_main *self)
{
global_work_size = MAX_KEYS_PER_CRYPT;
opencl_init("$JOHN/sha512_kernel.cl", ocl_gpu_id, platform_id);
///Alocate memory on the GPU
mem_in =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for passwords");
mem_out =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for hashes");
mem_binary =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, sizeof(uint64_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for binary");
mem_cmp =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, sizeof(uint32_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for cmp_all result");
///Assign crypt kernel parameters
crypt_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating crypt_kernel");
clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in);
clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out);
///Assign cmp kernel parameters
cmp_kernel = clCreateKernel(program[ocl_gpu_id], CMP_KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating cmp_kernel");
clSetKernelArg(cmp_kernel, 0, sizeof(mem_binary), &mem_binary);
clSetKernelArg(cmp_kernel, 1, sizeof(mem_out), &mem_out);
clSetKernelArg(cmp_kernel, 2, sizeof(mem_cmp), &mem_cmp);
opencl_find_best_workgroup(self);
fprintf(stderr, "Global work size = %lld\n",(long long)global_work_size);
atexit(release_all);
}
static void init(struct fmt_main *self)
{
size_t maxsize;
/* Read LWS/GWS prefs from config or environment */
opencl_get_user_preferences(OCL_CONFIG);
if (!local_work_size)
local_work_size = cpu(device_info[gpu_id]) ? 1 : 64;
if (!global_work_size)
global_work_size = MAX_KEYS_PER_CRYPT;
opencl_init("$JOHN/kernels/sha512_kernel.cl", gpu_id, NULL);
gkey = mem_calloc(global_work_size * sizeof(sha512_key));
ghash = mem_calloc(global_work_size * sizeof(sha512_hash));
///Allocate memory on the GPU
mem_in =
clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for passwords");
mem_out =
clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for hashes");
mem_binary =
clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, sizeof(uint64_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for binary");
mem_cmp =
clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, sizeof(uint32_t), NULL,
&ret_code);
HANDLE_CLERROR(ret_code,"Error while allocating memory for cmp_all result");
///Assign crypt kernel parameters
crypt_kernel = clCreateKernel(program[gpu_id], KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating crypt_kernel");
clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in);
clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out);
///Assign cmp kernel parameters
cmp_kernel = clCreateKernel(program[gpu_id], CMP_KERNEL_NAME, &ret_code);
HANDLE_CLERROR(ret_code,"Error while creating cmp_kernel");
clSetKernelArg(cmp_kernel, 0, sizeof(mem_binary), &mem_binary);
clSetKernelArg(cmp_kernel, 1, sizeof(mem_out), &mem_out);
clSetKernelArg(cmp_kernel, 2, sizeof(mem_cmp), &mem_cmp);
/* Note: we ask for the kernel's max size, not the device's! */
maxsize = get_kernel_max_lws(gpu_id, crypt_kernel);
if (local_work_size > maxsize) {
local_work_size = maxsize;
global_work_size = (global_work_size + local_work_size - 1) / local_work_size * local_work_size;
}
self->params.max_keys_per_crypt = global_work_size;
if (!local_work_size)
opencl_find_best_workgroup(self);
self->params.min_keys_per_crypt = local_work_size;
if (options.verbosity > 2)
fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n",(int)local_work_size, (int)global_work_size);
}
static void init(struct fmt_main *self)
{
cl_int cl_error;
char *temp;
char build_opts[64];
cl_ulong maxsize;
snprintf(build_opts, sizeof(build_opts),
"-DKEYLEN=%d -DSALTLEN=%d -DOUTLEN=%d",
PLAINTEXT_LENGTH,
(int)sizeof(currentsalt.salt),
(int)sizeof(outbuffer->v));
opencl_init_opt("$JOHN/kernels/pbkdf2_hmac_sha1_unsplit_kernel.cl",
ocl_gpu_id, build_opts);
if ((temp = getenv("LWS")))
local_work_size = atoi(temp);
else
local_work_size = cpu(device_info[ocl_gpu_id]) ? 1 : 64;
if ((temp = getenv("GWS")))
global_work_size = atoi(temp);
else
global_work_size = MAX_KEYS_PER_CRYPT;
crypt_kernel = clCreateKernel(program[ocl_gpu_id], "derive_key", &cl_error);
HANDLE_CLERROR(cl_error, "Error creating kernel");
/* Note: we ask for the kernels' max sizes, not the device's! */
HANDLE_CLERROR(clGetKernelWorkGroupInfo(crypt_kernel, devices[ocl_gpu_id], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize), &maxsize, NULL), "Query max workgroup size");
while (local_work_size > maxsize)
local_work_size >>= 1;
/// Allocate memory
inbuffer =
(zip_password *) mem_calloc(sizeof(zip_password) *
global_work_size);
outbuffer =
(zip_hash *) mem_alloc(sizeof(zip_hash) * global_work_size);
cracked = mem_calloc(sizeof(*cracked) * global_work_size);
/// Allocate memory
mem_in =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem in");
mem_setting =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_READ_ONLY, settingsize,
NULL, &cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem setting");
mem_out =
clCreateBuffer(context[ocl_gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem out");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 0, sizeof(mem_in),
&mem_in), "Error while setting mem_in kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 1, sizeof(mem_out),
&mem_out), "Error while setting mem_out kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 2, sizeof(mem_setting),
&mem_setting), "Error while setting mem_salt kernel argument");
self->params.max_keys_per_crypt = global_work_size;
if (!local_work_size)
opencl_find_best_workgroup(self);
self->params.min_keys_per_crypt = local_work_size;
if (options.verbosity > 2)
fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n", (int)local_work_size, (int)global_work_size);
}
