/* Convert Cisco hashes to hex ones, so .pot entries are compatible */
char * sha512_common_prepare_xsha(char *split_fields[10], struct fmt_main *self)
{
char Buf[200];
if (!strncmp(split_fields[1], XSHA512_FORMAT_TAG, XSHA512_TAG_LENGTH))
return split_fields[1];
if (split_fields[0] && strlen(split_fields[0]) == XSHA512_CIPHERTEXT_LENGTH) {
sprintf(Buf, "%s%s", XSHA512_FORMAT_TAG, split_fields[0]);
if (sha512_common_valid_xsha(Buf, self)) {
char *cp = mem_calloc_tiny(XSHA512_CIPHERTEXT_LENGTH+7,
MEM_ALIGN_NONE);
strcpy(cp, Buf);
return cp;
}
}
if (strlen(split_fields[1]) == XSHA512_CIPHERTEXT_LENGTH) {
sprintf(Buf, "%s%s", XSHA512_FORMAT_TAG, split_fields[1]);
if (sha512_common_valid_xsha(Buf, self)) {
char *cp = mem_calloc_tiny(XSHA512_CIPHERTEXT_LENGTH+7,
MEM_ALIGN_NONE);
strcpy(cp, Buf);
return cp;
}
}
return split_fields[1];
}
static void init(struct fmt_main *self)
{
MD5_CTX ctx;
int i;
unsigned char c;
unsigned char hash[16];
unsigned char out[33];
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
for(i = 0; i < 256; i++) {
c = i;
MD5_Init(&ctx);
MD5_Update(&ctx, &c, 1);
MD5_Final(hash, &ctx);
hex_encode(hash, 16, out);
memcpy(map[i], out, 32);
}
}
static void init(struct fmt_main *self)
{
/* OpenSSL init, cleanup part is left to OS */
SSL_load_error_strings();
SSL_library_init();
OpenSSL_add_all_algorithms();
#if defined(_OPENMP) && OPENSSL_VERSION_NUMBER >= 0x10000000
if (SSLeay() < 0x10000000) {
fprintf(stderr, "Warning: compiled against OpenSSL 1.0+, "
"but running with an older version -\n"
"disabling OpenMP for pfx because of thread-safety issues "
"of older OpenSSL\n");
fmt_pfx.params.min_keys_per_crypt =
fmt_pfx.params.max_keys_per_crypt = 1;
fmt_pfx.params.flags &= ~FMT_OMP;
}
else {
int omp_t = 1;
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
}
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_NONE);
any_cracked = 0;
cracked_size = sizeof(*cracked) * self->params.max_keys_per_crypt;
cracked = mem_calloc_tiny(cracked_size, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
#ifdef _OPENMP
int omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_plain = mem_calloc_tiny(sizeof(*saved_plain) * self->params.max_keys_per_crypt, MEM_ALIGN_NONE);
saved_len = mem_calloc_tiny(sizeof(*saved_len) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
output = mem_calloc_tiny(sizeof(*output) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
saved_ctx = mem_calloc_tiny(sizeof(*saved_ctx) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
OpenSSL_add_all_algorithms();
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
key_buffer = mem_calloc_tiny(sizeof(*key_buffer) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *pFmt)
{
#ifdef _OPENMP
int omp_t;
omp_t = omp_get_max_threads();
pFmt->params.min_keys_per_crypt = omp_t * MIN_KEYS_PER_CRYPT;
omp_t *= OMP_SCALE;
pFmt->params.max_keys_per_crypt = omp_t * MAX_KEYS_PER_CRYPT;
#endif
saved_key_length = mem_calloc_tiny(sizeof(*saved_key_length) * pFmt->params.max_keys_per_crypt, MEM_ALIGN_WORD);
saved_key = mem_calloc_tiny(sizeof(*saved_key) * pFmt->params.max_keys_per_crypt, MEM_ALIGN_NONE);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * pFmt->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *pFmt)
{
#ifdef _OPENMP
omp_t = omp_get_max_threads();
pFmt->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
pFmt->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
pFmt->params.max_keys_per_crypt, MEM_ALIGN_NONE);
any_cracked = 0;
cracked = mem_calloc_tiny(sizeof(*cracked) *
pFmt->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
#ifdef _OPENMP
int n = omp_get_max_threads();
if (n > 4) {
n = 4; // it just won't scale further
omp_set_num_threads(n);
}
self->params.max_keys_per_crypt = MAX_KEYS_PER_CRYPT * n;
#endif
//printf("Using %u x %u = %u keys per crypt\n", MAX_KEYS_PER_CRYPT, n, self->params.max_keys_per_crypt);
saved_key = mem_calloc_tiny(sizeof(*saved_key) * self->params.max_keys_per_crypt, MEM_ALIGN_NONE);
crcs = mem_calloc_tiny(sizeof(*crcs) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
#if defined (_OPENMP)
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
any_cracked = 0;
cracked_size = sizeof(*cracked) * self->params.max_keys_per_crypt;
cracked = mem_calloc_tiny(cracked_size, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
int i;
#ifdef _OPENMP
int omp_t;
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) * self->params.max_keys_per_crypt, MEM_ALIGN_CACHE);
for (i = 0; i < 8; i++)
crypt_key[i] = mem_calloc_tiny(sizeof(uint64_t) * self->params.max_keys_per_crypt, MEM_ALIGN_CACHE);
}
static void init(struct fmt_main *self)
{
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
/* Init bin 2 hex table for faster conversions later */
init_bin2hex(bin2hex_table);
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_NONE);
cracked = mem_calloc_tiny(sizeof(*cracked) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void *get_salt(char *ciphertext)
{
char *ctcopy = strdup(ciphertext);
char *keeptr = ctcopy;
int i;
char *p;
salt_struct = mem_calloc_tiny(sizeof(struct custom_salt),
MEM_ALIGN_WORD);
ctcopy += 11; /* skip over "$keychain$*" */
p = strtokm(ctcopy, "*");
for (i = 0; i < SALTLEN; i++)
salt_struct->salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
p = strtokm(NULL, "*");
for (i = 0; i < IVLEN; i++)
salt_struct->iv[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
p = strtokm(NULL, "*");
for (i = 0; i < CTLEN; i++)
salt_struct->ct[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
MEM_FREE(keeptr);
return (void *)salt_struct;
}
static void *get_salt(char *ciphertext)
{
char *ctcopy = strdup(ciphertext);
char *keeptr = ctcopy;
int i;
char *p;
ctcopy += 5; /* skip over "$pdf$" marker */
salt_struct = mem_calloc_tiny(sizeof(struct custom_salt), MEM_ALIGN_WORD);
/* restore serialized data */
salt_struct->e.s_handler = strtok(ctcopy, "*");
salt_struct->e.o_string = (uint8_t *) malloc(32);
p = strtok(NULL, "*");
for (i = 0; i < 32; i++)
salt_struct->e.o_string[i] =
atoi16[ARCH_INDEX(p[i * 2])] * 16 +
atoi16[ARCH_INDEX(p[i * 2 + 1])];
salt_struct->e.u_string = (uint8_t *) malloc(32);
p = strtok(NULL, "*");
for (i = 0; i < 32; i++)
salt_struct->e.u_string[i] =
atoi16[ARCH_INDEX(p[i * 2])] * 16 +
atoi16[ARCH_INDEX(p[i * 2 + 1])];
p = strtok(NULL, "*");
salt_struct->e.fileIDLen = atoi(p);
salt_struct->e.fileID = (uint8_t *) malloc(salt_struct->e.fileIDLen);
p = strtok(NULL, "*");
for (i = 0; i < salt_struct->e.fileIDLen; i++)
salt_struct->e.fileID[i] =
atoi16[ARCH_INDEX(p[i * 2])] * 16 +
atoi16[ARCH_INDEX(p[i * 2 + 1])];
p = strtok(NULL, "*");
salt_struct->e.encryptMetaData = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.work_with_user = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.have_userpassword = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.version_major = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.version_minor = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.length = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.permissions = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.revision = atoi(p);
p = strtok(NULL, "*");
salt_struct->e.version = atoi(p);
if (salt_struct->e.have_userpassword)
salt_struct->userpassword = (unsigned char *)strtok(NULL, "*");
free(keeptr);
/* try to initialize the cracking-engine */
if (!initPDFCrack(salt_struct)) {
fprintf(stderr, "Wrong userpassword, '%s'\n", salt_struct->userpassword);
exit(-1);
}
return (void *)salt_struct;
}
static void *get_salt(char *ciphertext)
{
char *ctcopy = strdup(ciphertext);
char *keeptr = ctcopy;
char *p;
int i;
static pwsafe_salt *salt_struct;
if (!salt_struct)
salt_struct = mem_calloc_tiny(sizeof(pwsafe_salt),
MEM_ALIGN_WORD);
ctcopy += 9; /* skip over "$pwsafe$*" */
p = strtok(ctcopy, "*");
salt_struct->version = atoi(p);
p = strtok(NULL, "*");
for (i = 0; i < 32; i++)
salt_struct->salt[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
p = strtok(NULL, "*");
salt_struct->iterations = (unsigned int) atoi(p);
p = strtok(NULL, "*");
for (i = 0; i < 32; i++)
salt_struct->hash[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
MEM_FREE(keeptr);
alter_endianity(salt_struct->hash, 32);
return (void *) salt_struct;
}
void init(struct fmt_main *self) {
const char *pos;
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
memset(_atoi64, 0x7F, sizeof(_atoi64));
for (pos = _itoa64; pos <= &_itoa64[63]; pos++)
_atoi64[ARCH_INDEX(*pos)] = pos - _itoa64;
}
static void init(struct fmt_main *self)
{
CRC32_t crc;
#if defined (_OPENMP)
int omp_t = 1;
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
cracked = mem_calloc_tiny(sizeof(*cracked) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
CRC32_Init(&crc);
}
static void fmt_vms_init ( struct fmt_main *self )
{
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
/* Init bin 2 hex table for faster conversions later */
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * self->params.max_keys_per_crypt, sizeof(uaf_qword));
if (!initialized) {
uaf_init();
initialized = 1;
}
}
static void init(struct fmt_main *self)
{
char *Buf;
#ifdef _OPENMP
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
saved_key = mem_calloc_tiny(sizeof(*saved_key) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
cracked = mem_calloc_tiny(sizeof(*cracked) *
self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
aesFunc = get_AES_dec192_CBC();
Buf = mem_alloc_tiny(128, 1);
sprintf(Buf, "%s %s", self->params.algorithm_name, get_AES_type_string());
self->params.algorithm_name=Buf;
}
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);
}
char * sha512_common_split_xsha(char *ciphertext, int index, struct fmt_main *pFmt)
{
static char * out;
if (!out) out = mem_calloc_tiny(8 + XSHA512_CIPHERTEXT_LENGTH + 1, MEM_ALIGN_WORD);
if (!strncmp(ciphertext, XSHA512_FORMAT_TAG, XSHA512_TAG_LENGTH))
return ciphertext;
memcpy(out, XSHA512_FORMAT_TAG, XSHA512_TAG_LENGTH);
memcpy(out + XSHA512_TAG_LENGTH, ciphertext, XSHA512_CIPHERTEXT_LENGTH + 1);
strlwr(out + XSHA512_TAG_LENGTH);
return out;
}
static void init(struct fmt_main *pFmt)
{
MD5_std_init(pFmt);
#if defined(_OPENMP) && defined(MD5_SSE_PARA)
omp_para = omp_get_max_threads();
if (omp_para < 1)
omp_para = 1;
pFmt->params.min_keys_per_crypt = MD5_N * omp_para;
omp_para *= OMP_SCALE;
pFmt->params.max_keys_per_crypt = MD5_N * omp_para;
#elif MD5_std_mt
pFmt->params.min_keys_per_crypt = MD5_std_min_kpc;
pFmt->params.max_keys_per_crypt = MD5_std_max_kpc;
#endif
saved_key = mem_calloc_tiny(
sizeof(*saved_key) * pFmt->params.max_keys_per_crypt,
MEM_ALIGN_CACHE);
#ifdef MD5_SSE_PARA
sout = mem_calloc_tiny(sizeof(*sout) *
pFmt->params.max_keys_per_crypt *
BINARY_SIZE, sizeof(MD5_word));
#endif
}
static void init(struct fmt_main *self)
{
#ifdef _OPENMP
int n = omp_get_max_threads();
if (n < 1)
n = 1;
n *= 2;
if (n > self->params.max_keys_per_crypt)
n = self->params.max_keys_per_crypt;
self->params.min_keys_per_crypt = n;
#endif
crypt_key = mem_calloc_tiny(
(sizeof(*crypt_key) + sizeof(*saved_key)) *
self->params.max_keys_per_crypt,
MEM_ALIGN_CACHE);
saved_key = (void *)((char *)crypt_key +
sizeof(*crypt_key) * self->params.max_keys_per_crypt);
}
/* ------- Binary ------- */
void * sha512_common_binary(char *ciphertext)
{
static unsigned char * out;
char *p;
int i;
if (!out) out = mem_calloc_tiny(BINARY_SIZE, MEM_ALIGN_WORD);
p = ciphertext + TAG_LENGTH;
for (i = 0; i < BINARY_SIZE; i++) {
out[i] =
(atoi16[ARCH_INDEX(*p)] << 4) |
atoi16[ARCH_INDEX(p[1])];
p += 2;
}
#ifdef SIMD_COEF_64
alter_endianity_to_BE64(out, BINARY_SIZE/8);
#endif
return out;
}
static void init(struct fmt_main *self)
{
#ifdef CL_VERSION_1_0
char *temp;
cl_ulong maxsize;
global_work_size = 0;
opencl_init("$JOHN/rar_kernel.cl", ocl_gpu_id, platform_id);
// create kernel to execute
crypt_kernel = clCreateKernel(program[ocl_gpu_id], "SetCryptKeys", &ret_code);
HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?");
/* We mimic the lengths of cRARk for comparisons */
if (get_device_type(ocl_gpu_id) == CL_DEVICE_TYPE_GPU) {
#ifndef DEBUG
self->params.benchmark_comment = " (6 characters)";
#endif
self->params.tests = gpu_tests;
#if defined(DEBUG) && !defined(ALWAYS_OPENCL)
fprintf(stderr, "Note: will use CPU for some self-tests, and Single mode.\n");
#endif
}
if ((temp = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, LWS_CONFIG)))
local_work_size = atoi(temp);
if ((temp = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, GWS_CONFIG)))
global_work_size = atoi(temp);
if ((temp = getenv("LWS")))
local_work_size = atoi(temp);
if ((temp = getenv("GWS")))
global_work_size = atoi(temp);
/* Note: we ask for this kernel's max size, not the device's! */
HANDLE_CLERROR(clGetKernelWorkGroupInfo(crypt_kernel, devices[ocl_gpu_id], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize), &maxsize, NULL), "Query max work group size");
#ifdef DEBUG
fprintf(stderr, "Max allowed local work size %d\n", (int)maxsize);
#endif
if (!local_work_size) {
if (get_device_type(ocl_gpu_id) == CL_DEVICE_TYPE_CPU) {
if (get_platform_vendor_id(platform_id) == INTEL)
local_work_size = 8;
else
local_work_size = 1;
} else {
local_work_size = 64;
}
}
if (local_work_size > maxsize) {
fprintf(stderr, "LWS %d is too large for this GPU. Max allowed is %d, using that.\n", (int)local_work_size, (int)maxsize);
local_work_size = maxsize;
}
if (!global_work_size)
find_best_gws(temp == NULL ? 0 : 1);
if (global_work_size < local_work_size)
global_work_size = local_work_size;
fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n", (int)local_work_size, (int)global_work_size);
create_clobj(global_work_size);
#ifdef DEBUG
{
cl_ulong loc_mem_size;
HANDLE_CLERROR(clGetKernelWorkGroupInfo(crypt_kernel, devices[ocl_gpu_id], CL_KERNEL_LOCAL_MEM_SIZE, sizeof(loc_mem_size), &loc_mem_size, NULL), "Query local memory usage");
fprintf(stderr, "Kernel using %lu bytes of local memory out of %lu available\n", loc_mem_size, get_local_memory_size(ocl_gpu_id));
}
#endif
atexit(release_clobj);
*mkpc = VF * global_work_size;
#endif /* OpenCL */
#if defined (_OPENMP)
omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
#ifndef CL_VERSION_1_0 /* OpenCL gets to decide */
*mkpc = omp_t * OMP_SCALE * MAX_KEYS_PER_CRYPT;
#endif
init_locks();
#endif /* _OPENMP */
if (options.utf8)
self->params.plaintext_length = PLAINTEXT_LENGTH * 3;
unpack_data = mem_calloc_tiny(sizeof(unpack_data_t) * omp_t, MEM_ALIGN_WORD);
cracked = mem_calloc_tiny(sizeof(*cracked) * *mkpc, MEM_ALIGN_WORD);
#ifndef CL_VERSION_1_0
saved_key = mem_calloc_tiny(UNICODE_LENGTH * *mkpc, MEM_ALIGN_NONE);
saved_len = mem_calloc_tiny(sizeof(*saved_len) * *mkpc, MEM_ALIGN_WORD);
saved_salt = mem_calloc_tiny(8, MEM_ALIGN_NONE);
aes_key = mem_calloc_tiny(16 * *mkpc, MEM_ALIGN_NONE);
aes_iv = mem_calloc_tiny(16 * *mkpc, MEM_ALIGN_NONE);
#endif
/* OpenSSL init */
init_aesni();
SSL_load_error_strings();
SSL_library_init();
OpenSSL_add_all_algorithms();
#ifndef __APPLE__
atexit(openssl_cleanup);
#endif
/* CRC-32 table init, do it before we start multithreading */
{
CRC32_t crc;
CRC32_Init(&crc);
}
}
// NOTE, this still needs work. I am sure this will not eliminate (compact out)
// duplicate salts.
static void *get_salt(char *ciphertext)
{
sip_salt *salt;
static char saltBuf[2048];
char *lines[16];
login_t login;
int num_lines;
MD5_CTX md5_ctx;
unsigned char md5_bin_hash[MD5_LEN];
char static_hash[MD5_LEN_HEX+1];
char *saltcopy = saltBuf;
salt = mem_calloc_tiny(sizeof(sip_salt), MEM_ALIGN_NONE);
strcpy(saltBuf, ciphertext);
saltcopy += 6; /* skip over "$sip$*" */
memset(&login, 0, sizeof(login_t));
num_lines = stringtoarray(lines, saltcopy, '*');
assert(num_lines == 14);
strncpy(login.server, lines[0], sizeof(login.server) - 1 );
strncpy(login.client, lines[1], sizeof(login.client) - 1 );
strncpy(login.user, lines[2], sizeof(login.user) - 1 );
strncpy(login.realm, lines[3], sizeof(login.realm) - 1 );
strncpy(login.method, lines[4], sizeof(login.method) - 1 );
/* special handling for uri */
if (!strcmp(lines[7], ""))
sprintf(login.uri, "%s:%s", lines[5], lines[6]);
else
sprintf(login.uri, "%s:%s:%s", lines[5], lines[6], lines[7]);
strncpy(login.nonce, lines[8], sizeof(login.nonce) - 1 );
strncpy(login.cnonce, lines[9], sizeof(login.cnonce) - 1 );
strncpy(login.nonce_count, lines[10], sizeof(login.nonce_count) - 1 );
strncpy(login.qop, lines[11], sizeof(login.qop) - 1 );
strncpy(login.algorithm, lines[12], sizeof(login.algorithm) - 1 );
strncpy(login.hash, lines[13], sizeof(login.hash) - 1 );
if(strncmp(login.algorithm, "MD5", strlen(login.algorithm))) {
printf("\n* Cannot crack '%s' hash, only MD5 supported so far...\n", login.algorithm);
exit(-1);
}
/* Generating MD5 static hash: 'METHOD:URI' */
MD5_Init(&md5_ctx);
MD5_Update(&md5_ctx, (unsigned char*)login.method, strlen( login.method ));
MD5_Update(&md5_ctx, (unsigned char*)":", 1);
MD5_Update(&md5_ctx, (unsigned char*)login.uri, strlen( login.uri ));
MD5_Final(md5_bin_hash, &md5_ctx);
bin_to_hex(bin2hex_table, md5_bin_hash, MD5_LEN, static_hash, MD5_LEN_HEX);
/* Constructing first part of dynamic hash: 'USER:REALM:' */
salt->dynamic_hash_data = salt->Buf;
snprintf(salt->dynamic_hash_data, DYNAMIC_HASH_SIZE, "%s:%s:", login.user, login.realm);
salt->dynamic_hash_data_len = strlen(salt->dynamic_hash_data);
/* Construct last part of final hash data: ':NONCE(:CNONCE:NONCE_COUNT:QOP):<static_hash>' */
/* no qop */
salt->static_hash_data = &(salt->Buf[salt->dynamic_hash_data_len+1]);
if(!strlen(login.qop))
snprintf(salt->static_hash_data, STATIC_HASH_SIZE, ":%s:%s", login.nonce, static_hash);
/* qop/conce/cnonce_count */
else
snprintf(salt->static_hash_data, STATIC_HASH_SIZE, ":%s:%s:%s:%s:%s",
login.nonce, login.nonce_count, login.cnonce,
login.qop, static_hash);
/* Get lens of static buffers */
salt->static_hash_data_len = strlen(salt->static_hash_data);
/* Begin brute force attack */
#ifdef SIP_DEBUG
printf("Starting bruteforce against user '%s' (%s: '%s')\n",
login.user, login.algorithm, login.hash);
#endif
strcpy(salt->login_hash, login.hash);
return salt;
}
static void init(struct fmt_main *self)
{
#ifdef SIMD_COEF_64
int i;
#endif
#ifdef _OPENMP
int omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
#ifdef SIMD_COEF_64
bufsize = sizeof(ARCH_WORD_64) * self->params.max_keys_per_crypt * SHA_BUF_SIZ;
crypt_key = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
ipad = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
opad = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
prep_ipad = mem_calloc_tiny(self->params.max_keys_per_crypt * BINARY_SIZE_512, MEM_ALIGN_SIMD);
prep_opad = mem_calloc_tiny(self->params.max_keys_per_crypt * BINARY_SIZE_512, MEM_ALIGN_SIMD);
for (i = 0; i < self->params.max_keys_per_crypt; ++i) {
crypt_key[GETPOS(BINARY_SIZE, i)] = 0x80;
((ARCH_WORD_64*)crypt_key)[15 * SIMD_COEF_64 + (i & (SIMD_COEF_64-1)) + (i/SIMD_COEF_64) * SHA_BUF_SIZ * SIMD_COEF_64] = (BINARY_SIZE + PAD_SIZE) << 3;
}
clear_keys();
#else
crypt_key = mem_calloc_tiny(sizeof(*crypt_key) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
ipad = mem_calloc_tiny(sizeof(*ipad) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
opad = mem_calloc_tiny(sizeof(*opad) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
ipad_ctx = mem_calloc_tiny(sizeof(*ipad_ctx) * self->params.max_keys_per_crypt, 8);
opad_ctx = mem_calloc_tiny(sizeof(*opad_ctx) * self->params.max_keys_per_crypt, 8);
#endif
saved_plain = mem_calloc_tiny(sizeof(*saved_plain) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
static void init(struct fmt_main *self)
{
saved_key = mem_calloc_tiny(sizeof(*saved_key) * MAX_KEYS_PER_CRYPT, MEM_ALIGN_WORD);
saved_key_length = mem_calloc_tiny(sizeof(*saved_key_length) * MAX_KEYS_PER_CRYPT, MEM_ALIGN_WORD);
crypt_out = mem_calloc_tiny(sizeof(*crypt_out) * MAX_KEYS_PER_CRYPT, MEM_ALIGN_WORD);
}
