WIN32DLL_DEFINE
int mcrypt_generic_deinit( MCRYPT td)
{
if (td==NULL || td->keyword_given==NULL) return MCRYPT_UNKNOWN_ERROR;
internal_end_mcrypt(td);
return 0;
}
WIN32DLL_DEFINE
int mcrypt_generic_end( MCRYPT td)
{
if (td==NULL) return MCRYPT_UNKNOWN_ERROR;
if (td->keyword_given!=NULL)
internal_end_mcrypt(td);
mcrypt_module_close(td);
return 0;
}
static int internal_init_mcrypt(MCRYPT td, const void *key, int lenofkey, const void *IV)
{
int *sizes = NULL;
int num_of_sizes, i, ok = 0;
int key_size = mcrypt_enc_get_key_size(td);
if (lenofkey > key_size || lenofkey==0) {
return MCRYPT_KEY_LEN_ERROR; /* error */
}
sizes = mcrypt_enc_get_supported_key_sizes(td, &num_of_sizes);
if (sizes != NULL) {
for (i = 0; i < num_of_sizes; i++) {
if (lenofkey == sizes[i]) {
ok = 1;
break;
}
}
} else { /* sizes==NULL */
if (num_of_sizes == 0
&& lenofkey <= mcrypt_enc_get_key_size(td))
ok = 1;
}
if (ok == 0) { /* not supported key size */
key_size = mcrypt_enc_get_key_size(td);
if (sizes != NULL) {
for (i = 0; i < num_of_sizes; i++) {
if (lenofkey <= sizes[i]) {
key_size = sizes[i];
break;
}
}
} else { /* well every key size is supported! */
key_size = lenofkey;
}
} else {
key_size = lenofkey;
}
free(sizes);
td->keyword_given = mxcalloc(1, mcrypt_enc_get_key_size(td));
if (td->keyword_given==NULL) return MCRYPT_MEMORY_ALLOCATION_ERROR;
memmove(td->keyword_given, key, lenofkey);
i = mcrypt_get_size(td);
td->akey = mxcalloc(1, i);
if (td->akey==NULL) {
free(td->keyword_given);
return MCRYPT_MEMORY_ALLOCATION_ERROR;
}
i = mcrypt_mode_get_size(td);
if (i > 0) {
td->abuf = mxcalloc(1, i);
if (td->abuf==NULL) {
free(td->keyword_given);
free(td->akey);
return MCRYPT_MEMORY_ALLOCATION_ERROR;
}
}
ok = init_mcrypt(td, td->abuf, key, key_size, IV);
if (ok!=0) {
free(td->keyword_given);
free(td->akey);
free(td->abuf);
return MCRYPT_UNKNOWN_ERROR; /* algorithm error */
}
ok = mcrypt_set_key(td,
(void *) td->akey,
(void *) td->keyword_given,
key_size, IV, IV!=NULL ? mcrypt_enc_get_iv_size(td) : 0);
if (ok!=0) {
internal_end_mcrypt(td);
return MCRYPT_UNKNOWN_ERROR; /* algorithm error */
}
return 0;
}
void gf_crypt_deinit(GF_Crypt *td)
{
internal_end_mcrypt(td);
}
GF_EXPORT
GF_Err gf_crypt_init(GF_Crypt *td, void *key, u32 lenofkey, const void *IV)
{
GF_Err e;
u32 sizes[MAX_KEY_SIZES];
u32 i, num_of_sizes, ok = 0;
u32 key_size = gf_crypt_get_key_size(td);
if ((lenofkey > key_size) || (lenofkey==0)) return GF_BAD_PARAM;
num_of_sizes = gf_crypt_get_supported_key_sizes(td, sizes);
if (num_of_sizes) {
for (i=0; i < num_of_sizes; i++) {
if (lenofkey == sizes[i]) {
ok = 1;
break;
}
}
} else if (lenofkey <= gf_crypt_get_key_size(td)) {
ok = 1;
}
if (ok == 0) { /* not supported key size */
key_size = gf_crypt_get_key_size(td);
if (sizes != NULL) {
for (i = 0; i < num_of_sizes; i++) {
if (lenofkey <= sizes[i]) {
key_size = sizes[i];
break;
}
}
} else { /* well every key size is supported! */
key_size = lenofkey;
}
} else {
key_size = lenofkey;
}
td->keyword_given = (char*)gf_malloc(sizeof(char)*gf_crypt_get_key_size(td));
if (td->keyword_given==NULL) return GF_OUT_OF_MEM;
memmove(td->keyword_given, key, lenofkey);
td->akey = (char*)gf_malloc(sizeof(char)*td->algo_size);
if (td->akey==NULL) {
gf_free(td->keyword_given);
return GF_OUT_OF_MEM;
}
if (td->mode_size > 0) {
td->abuf = (char*)gf_malloc(sizeof(char)*td->mode_size);
if (td->abuf==NULL) {
gf_free(td->keyword_given);
gf_free(td->akey);
return GF_OUT_OF_MEM;
}
}
e = td->_init_mcrypt(td->abuf, (void *) key, key_size, (void *) IV, gf_crypt_get_block_size(td));
if (e!=GF_OK) {
gf_free(td->keyword_given);
gf_free(td->akey);
gf_free(td->abuf);
return e;
}
e = gf_crypt_set_key(td, (void *) td->keyword_given, key_size, IV);
if (e!=GF_OK) internal_end_mcrypt(td);
return e;
}
GF_EXPORT
void gf_crypt_close(GF_Crypt *td)
{
internal_end_mcrypt(td);
gf_free(td);
}
