static int valid(char *ciphertext, struct fmt_main *self)
{
char *ptr, *ctcopy, *keeptr;
if (strncmp(ciphertext, "$episerver$*", 12))
return 0;
if (!(ctcopy = strdup(ciphertext)))
return 0;
keeptr = ctcopy;
ctcopy += 12; /* skip leading '$episerver$*' */
if (strlen(ciphertext) > 255)
goto error;
if (!(ptr = strtokm(ctcopy, "*")))
goto error;
/* check version, must be '0' or '1' */
if (*ptr != '0' && *ptr != '1')
goto error;
if (!(ptr = strtokm(NULL, "*"))) /* salt */
goto error;
if (strlen(ptr) > 24)
goto error;
if (!(ptr = strtokm(NULL, "*"))) /* hash */
goto error;
if (strlen(ptr) > 44)
goto error;
if ((ptr = strtokm(NULL, "*"))) /* end */
goto error;
MEM_FREE(keeptr);
return 1;
error:
MEM_FREE(keeptr);
return 0;
}
/* Free font record */
static void freeFonts(tcCtx g) {
tcprivCtx h = g->ctx.tcpriv;
int i;
/* Free font data */
for (i = 0; i < h->set.cnt; i++) {
Font *font = &h->set.array[i];
MEM_FREE(g, font->FontName);
dnaFREE(font->dict);
dnaFREE(font->Private);
csFreeFont(g, font);
if (font->flags & FONT_CID) {
int fdCount = font->fdCount;
int fd;
if (font->fdInfo) {
for (fd = 0; fd < fdCount; fd++) {
dnaFREE(font->fdInfo[fd].FD);
dnaFREE(font->fdInfo[fd].Private);
}
MEM_FREE(g, font->fdInfo);
}
MEM_FREE(g, font->fdIndex);
}
MEM_FREE(g, font->chameleon.data);
(void)fontInit(g, 1, font); /* Prepare to reuse */
}
h->set.cnt = 0;
}
static void done(void)
{
/* FIXME: How do we de-init cuda stuff? */
MEM_FREE(ghash);
MEM_FREE(g_ext_key);
MEM_FREE(gkey);
}
/*
* sets the current section
*/
int (conf_section)(const char *sec)
{
size_t len;
char buf[30], *pbuf;
const char *hkey;
table_t *tab;
assert(sec);
/* sepunit() always clears errcode */
len = strlen(sec);
pbuf = strcpy((len > sizeof(buf)-1)? MEM_ALLOC(len+1): buf, sec);
if (sepunit(pbuf, &pbuf) != CONF_ERR_OK) {
if (pbuf != buf)
MEM_FREE(pbuf);
return errcode; /* sepunit sets errcode */
}
hkey = hash_string((control & CONF_OPT_CASE)? pbuf: lower(pbuf));
if (pbuf != buf)
MEM_FREE(pbuf);
tab = table_get(section, hkey);
if (tab)
current = tab;
else
errcode = CONF_ERR_SEC;
return errcode;
}
/*******************************************************************************
*
* Helper functions.
*
******************************************************************************/
static enum sl_error
ensure_allocated(struct sl_vector* vec, size_t capacity, bool keep_data)
{
void* buffer = NULL;
enum sl_error sl_err = SL_NO_ERROR;
ASSERT(vec);
if(capacity > vec->capacity) {
size_t new_capacity = 0;
NEXT_POWER_OF_2(capacity, new_capacity);
buffer = MEM_ALIGNED_ALLOC
(vec->allocator, new_capacity * vec->data_size, vec->data_alignment);
if(!buffer) {
sl_err = SL_MEMORY_ERROR;
goto error;
}
if(keep_data) {
buffer = memcpy(buffer, vec->buffer, vec->capacity * vec->data_size);
}
MEM_FREE(vec->allocator, vec->buffer);
vec->buffer = buffer;
vec->capacity = new_capacity;
buffer = NULL;
}
exit:
return sl_err;
error:
if(buffer) {
MEM_FREE(vec->allocator, buffer);
buffer = NULL;
}
goto exit;
}
static int valid(char *ciphertext, struct fmt_main *self)
{
char *ctcopy, *keeptr, *p;
if (strncmp(ciphertext, "$keychain$*", 11) != 0)
return 0;
ctcopy = strdup(ciphertext);
keeptr = ctcopy;
ctcopy += 11;
if ((p = strtokm(ctcopy, "*")) == NULL) /* salt */
goto err;
if(strlen(p) != SALTLEN * 2)
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* iv */
goto err;
if(strlen(p) != IVLEN * 2)
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* ciphertext */
goto err;
if(strlen(p) != CTLEN * 2)
goto err;
MEM_FREE(keeptr);
return 1;
err:
MEM_FREE(keeptr);
return 0;
}
static void release_clobj(void)
{
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
MEM_FREE(ghash);
MEM_FREE(gkey);
}
void wav_free(RawSound* sound) {
assert(sound);
assert(sound->data);
MEM_FREE(sound->data);
sound->data = NULL;
MEM_FREE(sound);
}
static void done(void)
{
int i;
for (i = 0; i < 8; i++)
MEM_FREE(crypt_key[i]);
MEM_FREE(saved_key);
}
static void done(void)
{
MEM_FREE(crypt_out);
MEM_FREE(saved_key);
#ifndef SIMD_COEF_64
MEM_FREE(saved_len);
#endif
}
static void done(void)
{
MEM_FREE(crypt_key);
MEM_FREE(saved_key);
#ifdef SIMD_COEF_32
MEM_FREE(saved_len);
#endif
}
BOOL INSTAPI
SQLReadFileDSNW (LPCWSTR lpszFileName, LPCWSTR lpszAppName,
LPCWSTR lpszKeyName, LPWSTR lpszString, WORD cbString, WORD * pcbString)
{
char *_filename_u8 = NULL;
char *_appname_u8 = NULL;
char *_keyname_u8 = NULL;
char *_string_u8 = NULL;
BOOL retcode = FALSE;
_filename_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszFileName, SQL_NTS);
if (_filename_u8 == NULL && lpszFileName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_appname_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszAppName, SQL_NTS);
if (_appname_u8 == NULL && lpszAppName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_keyname_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszKeyName, SQL_NTS);
if (_keyname_u8 == NULL && lpszKeyName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
if (cbString > 0)
{
if ((_string_u8 = malloc (cbString * UTF8_MAX_CHAR_LEN + 1)) == NULL)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
}
retcode =
SQLReadFileDSN (_filename_u8, _appname_u8, _keyname_u8, _string_u8,
cbString * UTF8_MAX_CHAR_LEN, pcbString);
if (retcode == TRUE)
{
dm_StrCopyOut2_U8toW (_string_u8, lpszString, cbString, pcbString);
}
done:
MEM_FREE (_filename_u8);
MEM_FREE (_appname_u8);
MEM_FREE (_keyname_u8);
MEM_FREE (_string_u8);
return retcode;
}
static void find_best_workgroup(int jtrUniqDevNo) {
size_t _lws=0;
cl_device_type dTyp;
cl_command_queue cmdq;
cl_int err;
cl_uint *dcc_hash_host
= (cl_uint*)mem_alloc(4 * sizeof(cl_uint) * ((MAX_KEYS_PER_CRYPT < 65536) ? MAX_KEYS_PER_CRYPT : 65536));
cl_uint *dcc2_hash_host
= (cl_uint*)mem_alloc(4 * sizeof(cl_uint) * ((MAX_KEYS_PER_CRYPT < 65536) ? MAX_KEYS_PER_CRYPT : 65536));
cl_uint salt_api[9], length = 10;
event_ctr = 0;
//HANDLE_CLERROR(clGetDeviceInfo(devices[jtrUniqDevNo], CL_DEVICE_TYPE, sizeof(cl_device_type), &dTyp, NULL), "Failed Device Info");
dTyp = get_device_type(jtrUniqDevNo);
if (dTyp == CL_DEVICE_TYPE_CPU)
globalObj[jtrUniqDevNo].lws = 1;
else
globalObj[jtrUniqDevNo].lws = 16;
///Set Dummy DCC hash , unicode salt and ascii salt(username) length
memset(dcc_hash_host, 0xb5, 4 * sizeof(cl_uint) * ((MAX_KEYS_PER_CRYPT < 65536) ? MAX_KEYS_PER_CRYPT : 65536));
memset(salt_api, 0xfe, 9 * sizeof(cl_uint));
cmdq = clCreateCommandQueue(context[jtrUniqDevNo], devices[jtrUniqDevNo], CL_QUEUE_PROFILING_ENABLE, &err);
HANDLE_CLERROR(err, "Error creating command queue");
PROFILE = 1;
kernelExecTimeNs = CL_ULONG_MAX;
///Find best local work size
while (1) {
_lws = globalObj[jtrUniqDevNo].lws;
if (dTyp == CL_DEVICE_TYPE_CPU) {
exec_pbkdf2(dcc_hash_host, salt_api, length, dcc2_hash_host, 4096, jtrUniqDevNo, cmdq);
globalObj[jtrUniqDevNo].exec_time_inv = globalObj[jtrUniqDevNo].exec_time_inv / 16;
}
else {
exec_pbkdf2(dcc_hash_host, salt_api, length, dcc2_hash_host, ((MAX_KEYS_PER_CRYPT < 65536) ? MAX_KEYS_PER_CRYPT : 65536), jtrUniqDevNo, cmdq);
globalObj[jtrUniqDevNo].exec_time_inv *= ((MAX_KEYS_PER_CRYPT < 65536) ? MAX_KEYS_PER_CRYPT : 65536) / 65536;
}
if (globalObj[jtrUniqDevNo].lws <= _lws) break;
}
PROFILE = 0;
if (options.verbosity > 2) {
fprintf(stderr, "Optimal Work Group Size:%d\n", (int)globalObj[jtrUniqDevNo].lws);
fprintf(stderr, "Kernel Execution Speed (Higher is better):%Lf\n", globalObj[jtrUniqDevNo].exec_time_inv);
}
MEM_FREE(dcc_hash_host);
MEM_FREE(dcc2_hash_host);
HANDLE_CLERROR(clReleaseCommandQueue(cmdq), "Release Command Queue:Failed");
}
static void release_clobj(void)
{
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
HANDLE_CLERROR(clReleaseMemObject(mem_setting), "Release mem setting");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
MEM_FREE(inbuffer);
MEM_FREE(outbuffer);
MEM_FREE(cracked);
}
static void done(void)
{
int i;
for (i = 0; i < max_threads; i++)
escrypt_free_local(&local[i]);
MEM_FREE(local);
MEM_FREE(buffer);
}
static void release_clobj(void)
{
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
HANDLE_CLERROR(clReleaseMemObject(mem_salt), "Release mem salt");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
MEM_FREE(host_pass);
MEM_FREE(host_hash);
MEM_FREE(host_salt);
}
static int t13Support(cffCtx h)
{
/* Change op stack size */
MEM_FREE(h, h->stack.array);
MEM_FREE(h, h->stack.type);
h->stack.max = T13_MAX_OP_STACK;
h->stack.array = MEM_NEW(h, T13_MAX_OP_STACK * sizeof(StkElement));
h->stack.type = MEM_NEW(h, T13_MAX_OP_STACK);
return 1;
}
static void done(void)
{
if (overlap) {
cuda_pageLockedFree(inbuffer);
cuda_pageLockedFree(outbuffer);
} else {
MEM_FREE(inbuffer);
MEM_FREE(outbuffer);
}
}
void BF_clear_buffer() {
clean_gpu_buffer(&buffers[gpu_id]);
MEM_FREE(BF_current_S) ;
MEM_FREE(BF_current_P) ;
MEM_FREE(BF_init_key) ;
MEM_FREE(opencl_BF_out) ;
HANDLE_CLERROR(clReleaseKernel(krnl[gpu_id]), "Error releasing kernel") ;
HANDLE_CLERROR(clReleaseProgram(program[gpu_id]),
"Error releasing Program");
}
RETCODE SQL_API
SQLFreeConnect (HDBC hdbc)
{
GENV_t FAR *genv;
DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
DBC_t FAR *tpdbc;
if (hdbc == SQL_NULL_HDBC)
{
return SQL_INVALID_HANDLE;
}
/* check state */
if (pdbc->state != en_dbc_allocated)
{
PUSHSQLERR (pdbc->herr, en_S1010);
return SQL_ERROR;
}
genv = (GENV_t FAR *) pdbc->genv;
for (tpdbc = (DBC_t FAR *) genv->hdbc;
tpdbc != NULL;
tpdbc = tpdbc->next)
{
if (pdbc == tpdbc)
{
genv->hdbc = pdbc->next;
break;
}
if (pdbc == tpdbc->next)
{
tpdbc->next = pdbc->next;
break;
}
}
/* free this dbc */
_iodbcdm_driverunload (pdbc);
_iodbcdm_freesqlerrlist (pdbc->herr);
if (pdbc->tfile)
{
MEM_FREE (pdbc->tfile);
}
SQLSetConnectOption (pdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);
MEM_FREE (pdbc);
return SQL_SUCCESS;
}
static void release_clobj(void)
{
if (inbuffer) {
HANDLE_CLERROR(clReleaseMemObject(mem_state), "Release mem state");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
HANDLE_CLERROR(clReleaseMemObject(mem_salt), "Release mem setting");
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
MEM_FREE(output);
MEM_FREE(inbuffer);
}
}
BOOL INSTAPI
SQLGetAvailableDriversW (LPCWSTR lpszInfFile, LPWSTR lpszBuf, WORD cbBufMax,
WORD FAR * pcbBufOut)
{
BOOL retcode = FALSE;
char *_inf_u8 = NULL;
char *_buffer_u8 = NULL;
SQLCHAR *ptr;
SQLWCHAR *ptrW;
WORD len = 0, length;
_inf_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszInfFile, SQL_NTS);
if (_inf_u8 == NULL && lpszInfFile)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
if (cbBufMax > 0)
{
if ((_buffer_u8 = malloc (cbBufMax * UTF8_MAX_CHAR_LEN + 1)) == NULL)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
}
retcode =
SQLGetAvailableDrivers (_inf_u8, _buffer_u8,
cbBufMax * UTF8_MAX_CHAR_LEN, pcbBufOut);
if (retcode == TRUE)
{
length = 0;
for (ptr = _buffer_u8, ptrW = lpszBuf; *ptr;
ptr += STRLEN (ptr) + 1, ptrW += WCSLEN (ptrW) + 1)
{
dm_StrCopyOut2_U8toW (ptr, ptrW, cbBufMax - 1, &len);
length += len;
}
*ptrW = L'\0';
if (pcbBufOut)
*pcbBufOut = length + 1;
}
done:
MEM_FREE (_inf_u8);
MEM_FREE (_buffer_u8);
return retcode;
}
static void release_clobj(void)
{
if (host_crack) {
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
HANDLE_CLERROR(clReleaseMemObject(mem_salt), "Release mem salt");
HANDLE_CLERROR(clReleaseMemObject(mem_state), "Release mem state");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
MEM_FREE(inbuffer);
MEM_FREE(host_crack);
}
}
static void db_main_free(struct db_main *db)
{
if (db->format &&
(db->format->params.flags & FMT_DYNA_SALT) == FMT_DYNA_SALT) {
struct db_salt *psalt = db->salts;
while (psalt) {
dyna_salt_remove(psalt->salt);
psalt = psalt->next;
}
}
MEM_FREE(db->salt_hash);
MEM_FREE(db->cracked_hash);
}
void ldr_fix_database(struct db_main *db)
{
ldr_init_salts(db);
MEM_FREE(db->password_hash);
MEM_FREE(db->salt_hash);
ldr_remove_marked(db);
ldr_filter_salts(db);
ldr_init_hash(db);
db->loaded = 1;
}
TeelCmd tl_act_autocomplete(TeelInstance* ti)
{
if (!ti->autocomplete)
{
TL_PUTCHARS("\a"); // ding
return CMD_NOP;
}
char* path;
int cursor;
int linelen;
tl_editor_getline(ti, &path, &linelen, &cursor);
char** tab;
int nb;
ti->autocomplete(ti->ud, path, cursor, &nb, &tab);
if (!nb || !tab) // no auto complete proposals
{
MEM_FREE(path);
TL_PUTCHARS("\a"); // ding
return CMD_NOP;
}
else if (nb == 1 || ti->autocompletestate) // only one choice or choices have been showed already
completeline(ti, tab[0], strlen(tab[0]), path, cursor);
else
{
// Check if there is a common part in all choices, if so add it to the edited line
int i;
int l = strlen(tab[0]);
for (i=1; i<nb; i++)
{
l = cmp(tab[i-1], l, tab[i], strlen(tab[i]));
if (!l) break;
}
if (l)
completeline(ti, tab[0], l, path, cursor);
// Display all the choices as well
display_autocomplete_choices(ti, tab, nb);
ti->state = COMPLETION_DISP;
ti->autocompletestate = 1;
}
MEM_FREE(path);
MEM_FREE(tab);
return CMD_NOP;
}
int encfs_common_valid(char *ciphertext, struct fmt_main *self)
{
char *ctcopy;
char *keeptr;
char *p;
int res;
if (strncmp(ciphertext, "$encfs$", 7))
return 0;
ctcopy = strdup(ciphertext);
keeptr = ctcopy;
ctcopy += 7;
if ((p = strtokm(ctcopy, "*")) == NULL) /* key size */
goto err;
res = atoi(p);
if (res < 128 || res > MAX_KEYLENGTH*8)
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* iterations */
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* cipher */
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* salt length */
goto err;
res = atoi(p);
if (res > 40)
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* salt */
goto err;
if (res * 2 != strlen(p))
goto err;
if (!ishex(p))
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* data length */
goto err;
res = atoi(p);
if (res > 128)
goto err;
if ((p = strtokm(NULL, "*")) == NULL) /* data */
goto err;
if (res * 2 != strlen(p))
goto err;
if (!ishex(p))
goto err;
MEM_FREE(keeptr);
return 1;
err:
MEM_FREE(keeptr);
return 0;
}
BOOL INSTAPI
SQLWritePrivateProfileStringW (LPCWSTR lpszSection, LPCWSTR lpszEntry,
LPCWSTR lpszString, LPCWSTR lpszFilename)
{
char *_section_u8 = NULL;
char *_entry_u8 = NULL;
char *_string_u8 = NULL;
char *_filename_u8 = NULL;
BOOL retcode = FALSE;
_section_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszSection, SQL_NTS);
if (_section_u8 == NULL && lpszSection)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_entry_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszEntry, SQL_NTS);
if (_entry_u8 == NULL && lpszEntry)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_string_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszString, SQL_NTS);
if (_string_u8 == NULL && lpszString)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_filename_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszFilename, SQL_NTS);
if (_filename_u8 == NULL && lpszFilename)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
retcode =
SQLWritePrivateProfileString (_section_u8, _entry_u8, _string_u8,
_filename_u8);
done:
MEM_FREE (_section_u8);
MEM_FREE (_entry_u8);
MEM_FREE (_string_u8);
MEM_FREE (_filename_u8);
return retcode;
}
BOOL INSTAPI
SQLWriteFileDSNW (LPCWSTR lpszFileName, LPCWSTR lpszAppName,
LPCWSTR lpszKeyName, LPWSTR lpszString)
{
char *_filename_u8 = NULL;
char *_appname_u8 = NULL;
char *_keyname_u8 = NULL;
char *_string_u8 = NULL;
BOOL retcode = FALSE;
_filename_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszFileName, SQL_NTS);
if (_filename_u8 == NULL && lpszFileName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_appname_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszAppName, SQL_NTS);
if (_appname_u8 == NULL && lpszAppName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_keyname_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszKeyName, SQL_NTS);
if (_keyname_u8 == NULL && lpszKeyName)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_string_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszString, SQL_NTS);
if (_string_u8 == NULL && lpszString)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
retcode =
SQLWriteFileDSN (_filename_u8, _appname_u8, _keyname_u8, _string_u8);
done:
MEM_FREE (_filename_u8);
MEM_FREE (_appname_u8);
MEM_FREE (_keyname_u8);
MEM_FREE (_string_u8);
return retcode;
}
/* Get module into reusable state */
static void reuseInit(tcCtx g, encodingCtx h)
{
int i;
for (i = 0; i < h->encodings.cnt; i++)
{
Encoding *encoding = &h->encodings.array[i];
MEM_FREE(g, encoding->code);
if (encoding->supplement != NULL)
{
MEM_FREE(g, encoding->supplement);
encoding->supplement = NULL;
}
}
h->encodings.cnt = 0;
}
