libmcrypt/lib/mcrypt_modules.c

/*
 * Copyright (C) 1998,1999,2000,2001 Nikos Mavroyanopoulos
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Library General Public License as published 
 * by the Free Software Foundation; either version 2 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef LIBDEFS_H
#define LIBDEFS_H
#include <libdefs.h>
#endif
#include <bzero.h>
#include <mcrypt_internal.h>
#include <xmemory.h>

#ifndef DEBUG
# define fputs(x, y) 
#endif

extern const mcrypt_preloaded mps[];

#define MAX_MOD_SIZE 1024

static int mcrypt_strcmp( const char* str1, const char* str2) {
int i;
int len;
        if (strlen(str1)!=strlen(str2)) return -1;
        len = strlen(str1);

        for (i=0;i<len;i++) {
                if (str1[i]=='_' && str2[i]=='-') continue;
                if (str2[i]=='_' && str1[i]=='-') continue;
                if (str1[i]!=str2[i]) return -1;
        }
        
        return 0;
}

lt_ptr _mcrypt_search_symlist_lib(const char* name) {
int i=0;

        while( mps[i].name!=0 || mps[i].address!=0) {
                if (mps[i].name!=NULL && mps[i].address==NULL) {
                        if (mcrypt_strcmp(name, mps[i].name)==0) {
                                 return (void*) -1;
                        }
                }
                i++;
        }
        return NULL;
}

lt_ptr _mcrypt_search_symlist_sym(mcrypt_dlhandle handle, const char* _name) {
int i=0;
char name[MAX_MOD_SIZE];

        strcpy(name, handle.name);
        
        strcat( name, "_LTX_");
        strcat( name, _name);
        
        while( mps[i].name!=0 || mps[i].address!=0) {
                if (mps[i].name!=NULL) {
                        if (mcrypt_strcmp(name, mps[i].name)==0) {
                                 return mps[i].address;
                        }
                }
                i++;
        }
        return NULL;
}

void mcrypt_dlclose( mcrypt_dlhandle handle) {
void* mod = handle.handle;

        if (mod!=MCRYPT_INTERNAL_HANDLER && mod!=NULL)
                lt_dlclose(mod);
        handle.handle = NULL;
}

lt_ptr mcrypt_dlsym( mcrypt_dlhandle handle, char* str) {
void* mod;

        mod = handle.handle;
        
        if (mod!=MCRYPT_INTERNAL_HANDLER)
                return lt_dlsym(mod, str);
        else
                return _mcrypt_search_symlist_sym(handle, str);

}

WIN32DLL_DEFINE
int mcrypt_module_close(MCRYPT td)
{
        mcrypt_dlclose(td->algorithm_handle);
        mcrypt_dlclose(td->mode_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        td->m_encrypt = NULL;
        td->a_encrypt = NULL;
        td->a_decrypt = NULL;
        td->m_decrypt = NULL;

        free(td);
        
        return 0;
}


WIN32DLL_DEFINE
void* mcrypt_dlopen ( mcrypt_dlhandle* handle, const char* a_directory, const char *m_directory, const char *filename) {
        
        char paths[1526];

        if (strlen(filename) > sizeof( handle->name)) 
                return MCRYPT_FAILED;
        else
                strcpy( handle->name, filename);
                        
        if (_mcrypt_search_symlist_lib(filename)!=NULL) {
                handle->handle = MCRYPT_INTERNAL_HANDLER;
                return handle->handle;
        }
        
        memset( paths, 0, 1024);
        if (a_directory != NULL) {
                strncat( paths, a_directory, 512);
                strcat( paths, ":");
        }
        if (m_directory != NULL) {
                strncat( paths, m_directory, 512);
                strcat( paths, ":");
        }
        strncat( paths, LIBDIR, 512);

        lt_dlsetsearchpath(paths);

        handle->handle = lt_dlopenext(filename);

        return handle->handle;

}

WIN32DLL_DEFINE
MCRYPT mcrypt_module_open(char *algorithm,
                          char *a_directory, char *mode, char *m_directory)
{
        MCRYPT td;
        const char* err;
        void *ret;
        
        td = calloc(1, sizeof(CRYPT_STREAM));
        if (td==NULL) return MCRYPT_FAILED;

        if (lt_dlinit() != 0) {
                return MCRYPT_FAILED;
        }

        ret = mcrypt_dlopen( &td->algorithm_handle, a_directory, m_directory, algorithm);
        if (ret == NULL) {
                err=lt_dlerror();
                if (err!=NULL) fputs( err, stderr);
                fputs("\n", stderr);
                free(td);
                return MCRYPT_FAILED;
        }

        ret = mcrypt_dlopen( &td->mode_handle, a_directory, m_directory, mode);

        if (ret == NULL) {
                err=lt_dlerror();
                if (err!=NULL) fputs( err, stderr);
                mcrypt_dlclose(td->algorithm_handle);
                free(td);
                return MCRYPT_FAILED;
        }

        td->a_encrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_encrypt");
        td->a_decrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_decrypt");
        td->m_encrypt = mcrypt_dlsym(td->mode_handle, "_mcrypt");
        td->m_decrypt = mcrypt_dlsym(td->mode_handle, "_mdecrypt");
        td->a_block_size =
            mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_block_size");

        if (mcrypt_enc_is_block_algorithm_mode(td) !=
            mcrypt_enc_is_block_algorithm(td)) {
                mcrypt_module_close(td);
                return MCRYPT_FAILED;
        }

        return td;
}


/* Modules' frontends */

WIN32DLL_DEFINE
int mcrypt_get_size(MCRYPT td)
{
        int (*_mcrypt_get_size) (void);

        const char *error;

        _mcrypt_get_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_size");
        if (_mcrypt_get_size == NULL) {
                error = lt_dlerror();
                if (error!=NULL) fputs(error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }
        return _mcrypt_get_size();
}

WIN32DLL_DEFINE
int mcrypt_mode_get_size(MCRYPT td)
{
        int (*_mcrypt_get_size) (void);

        const char *error;

        _mcrypt_get_size = mcrypt_dlsym(td->mode_handle, "_mcrypt_mode_get_size");
        if (_mcrypt_get_size == NULL) {
                error = lt_dlerror();
                if (error!=NULL) fputs(error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }
        return _mcrypt_get_size();
}

WIN32DLL_DEFINE
int mcrypt_set_key(MCRYPT td, void *a, void *b, int c, void *d, int e)
{
        int (*__mcrypt_set_key_stream) (void *, void *, int, void *, int);
        int (*__mcrypt_set_key_block) (void *, void *, int);
        const char *error;

        if (mcrypt_enc_is_block_algorithm(td) == 0) {
                /* stream */
                __mcrypt_set_key_stream = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
                if (__mcrypt_set_key_stream == NULL) {
                        error = lt_dlerror();
                        if (error!=NULL) fputs(error, stderr);
                        fputs("\n", stderr);
                        return -2;
                }
                return __mcrypt_set_key_stream(a, b, c, d, e);
        } else {
                __mcrypt_set_key_block = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
                if (__mcrypt_set_key_block == NULL) {
                        error = lt_dlerror();
                        if (error!=NULL) fputs(error, stderr);
                        fputs("\n", stderr);
                        return -2;
                }
                return __mcrypt_set_key_block(a, b, c);
        }
}

WIN32DLL_DEFINE
int mcrypt_enc_set_state(MCRYPT td, void *iv, int size)
{
        int (*__mcrypt_set_state) (void *, void *, int);
        const char *error;

        __mcrypt_set_state = mcrypt_dlsym(td->mode_handle, "_mcrypt_set_state");
        if (__mcrypt_set_state==NULL) {
                error = lt_dlerror();
                if (error!=NULL) fputs(error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }
        return __mcrypt_set_state(td->abuf, iv, size);
}

WIN32DLL_DEFINE
int mcrypt_enc_get_block_size(MCRYPT td)
{
        int (*_mcrypt_get_block_size) (void);

        _mcrypt_get_block_size = td->a_block_size;
        return _mcrypt_get_block_size();
}

WIN32DLL_DEFINE
int mcrypt_get_algo_iv_size(MCRYPT td)
{
        int (*_mcrypt_get_algo_iv_size) (void);

        _mcrypt_get_algo_iv_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algo_iv_size");
        return _mcrypt_get_algo_iv_size();
}

WIN32DLL_DEFINE
int mcrypt_enc_get_iv_size(MCRYPT td)
{
        if (mcrypt_enc_is_block_algorithm_mode(td) == 1) {
                return mcrypt_enc_get_block_size(td);
        } else {
                return mcrypt_get_algo_iv_size(td);
        }
}

WIN32DLL_DEFINE
int mcrypt_enc_get_key_size(MCRYPT td)
{
        int (*_mcrypt_get_key_size) (void);

        _mcrypt_get_key_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_key_size");
        return _mcrypt_get_key_size();
}

WIN32DLL_DEFINE
const int *mcrypt_enc_get_supported_key_sizes(MCRYPT td, int *len)
{
        int *(*_mcrypt_get_key_sizes) (int *);
        int *size;

        _mcrypt_get_key_sizes =
            mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_supported_key_sizes");
        size = _mcrypt_get_key_sizes(len);

        return size;
}

WIN32DLL_DEFINE
int mcrypt_enc_is_block_algorithm(MCRYPT td)
{
        int (*_is_block_algorithm) (void);

        _is_block_algorithm = mcrypt_dlsym(td->algorithm_handle, "_is_block_algorithm");
        return _is_block_algorithm();
}

WIN32DLL_DEFINE
const char *mcrypt_enc_get_algorithms_name(MCRYPT td)
{
        const char *(*_mcrypt_get_algorithms_name) (void);

        _mcrypt_get_algorithms_name =
            mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algorithms_name");
        return _mcrypt_get_algorithms_name();
}

WIN32DLL_DEFINE
int init_mcrypt(MCRYPT td, void *buf, void *a, int b, void *c)
{
        int (*_init_mcrypt) (void *, void *, int, void *, int);

        _init_mcrypt = mcrypt_dlsym(td->mode_handle, "_init_mcrypt");
        return _init_mcrypt(buf, a, b, c, mcrypt_enc_get_block_size(td));
}

WIN32DLL_DEFINE
int end_mcrypt(MCRYPT td, void *buf)
{
        int (*_end_mcrypt) (void *);

        _end_mcrypt = mcrypt_dlsym(td->mode_handle, "_end_mcrypt");
        return _end_mcrypt(buf);
}

WIN32DLL_DEFINE
int mcrypt(MCRYPT td, void *buf, void *a, int b)
{
        int (*_mcrypt) (void *, void *, int, int, void *, void *, void*);
        _mcrypt = td->m_encrypt;

        return _mcrypt(buf, a, b, mcrypt_enc_get_block_size(td), td->akey,
                       td->a_encrypt, td->a_decrypt);
}

WIN32DLL_DEFINE
int mdecrypt(MCRYPT td, void *buf, void *a, int b)
{
        int (*_mdecrypt) (void *, void *, int, int, void *, void *, void*);

        _mdecrypt = td->m_decrypt;
        return _mdecrypt(buf, a, b, mcrypt_enc_get_block_size(td),
                         td->akey, td->a_encrypt, td->a_decrypt);
}

WIN32DLL_DEFINE
const char *mcrypt_enc_get_modes_name(MCRYPT td)
{
        const char *(*_mcrypt_get_modes_name) (void);

        _mcrypt_get_modes_name = mcrypt_dlsym(td->mode_handle, "_mcrypt_get_modes_name");
        return _mcrypt_get_modes_name();
}

WIN32DLL_DEFINE
int mcrypt_enc_is_block_mode(MCRYPT td)
{
        int (*_is_block_mode) (void);

        _is_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_mode");
        return _is_block_mode();
}

WIN32DLL_DEFINE
int mcrypt_enc_mode_has_iv(MCRYPT td)
{
        int (*_has_iv) (void);

        _has_iv = mcrypt_dlsym(td->mode_handle, "_has_iv");
        return _has_iv();
}

WIN32DLL_DEFINE
int mcrypt_enc_is_block_algorithm_mode(MCRYPT td)
{
        int (*_is_a_block_mode) (void);

        _is_a_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_algorithm_mode");
        return _is_a_block_mode();
}

WIN32DLL_DEFINE
int mcrypt_enc_self_test(MCRYPT td)
{
        int (*_self_test) (void);

        _self_test = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_self_test");

        return _self_test();
}

WIN32DLL_DEFINE
int mcrypt_module_self_test(char *algorithm, char *a_directory)
{
        int i;
        void* rr;
        mcrypt_dlhandle _handle;
        int (*_self_test) (void);
        const char* error;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);

        if (!rr) {
                error=lt_dlerror();
                if (error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                lt_dlexit();
                return MCRYPT_UNKNOWN_ERROR;
        }

        _self_test = mcrypt_dlsym(_handle, "_mcrypt_self_test");

        i = _self_test();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_algorithm_version(char *algorithm, char *a_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_version) (void);
        const char* error;
        void* rr;
        
        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);
        if (!rr) {
                error=lt_dlerror();
                if (error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");

        i = _version();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_mode_version(char *mode, char *m_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_version) (void);
        const char* error;
        void * rr;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs(error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _version = mcrypt_dlsym( _handle, "_mcrypt_mode_version");

        i = _version();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_is_block_algorithm(char *algorithm, char *a_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_is_block_algorithm) (void);
        const char* error;
        void * rr;
        
        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _is_block_algorithm = mcrypt_dlsym(_handle, "_is_block_algorithm");

        i = _is_block_algorithm();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_is_block_algorithm_mode(char *mode, char *m_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_is_a_block_mode) (void);
        const char* error;
        void * rr;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _is_a_block_mode = mcrypt_dlsym(_handle, "_is_block_algorithm_mode");

        i = _is_a_block_mode();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_is_block_mode(char *mode, char *m_directory)
{
        void * rr;
        int i;
        mcrypt_dlhandle _handle;
        int (*_is_block_mode) (void);
        const char* error;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _is_block_mode = mcrypt_dlsym(_handle, "_is_block_mode");

        i = _is_block_mode();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_get_algo_block_size(char *algorithm, char *a_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_get_block_size) (void);
        const char* error;
        void * rr;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _get_block_size = mcrypt_dlsym(_handle, "_mcrypt_get_block_size");

        i = _get_block_size();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int mcrypt_module_get_algo_key_size(char *algorithm, char *a_directory)
{
        int i;
        mcrypt_dlhandle _handle;
        int (*_get_key_size) (void);
        const char* error;
        void * rr;

        if (lt_dlinit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                return MCRYPT_UNKNOWN_ERROR;
        }

        _get_key_size = mcrypt_dlsym(_handle, "_mcrypt_get_key_size");

        i = _get_key_size();

        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return MCRYPT_UNKNOWN_ERROR;
        }

        return i;
}

WIN32DLL_DEFINE
int *mcrypt_module_get_algo_supported_key_sizes(char *algorithm,
                                                char *a_directory,
                                                int *len)
{
        mcrypt_dlhandle _handle;
        int *(*_mcrypt_get_key_sizes) (int *);
        int *size;
        int * ret_size;
        const char* error;
        void * rr;
        
        if (lt_dlinit() != 0) {
                *len = 0;
                return NULL;
        }

        rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
        if (!rr) {
                error=lt_dlerror();
                if(error!=NULL) fputs( error, stderr);
                fputs("\n", stderr);
                *len = 0;
                return NULL;
        }

        _mcrypt_get_key_sizes =
            mcrypt_dlsym(_handle, "_mcrypt_get_supported_key_sizes");

        size = _mcrypt_get_key_sizes(len);
        if (len!=0) {
                ret_size = malloc( (*len)*sizeof(int));
                if (ret_size!=NULL) {
                        memcpy( ret_size, size, (*len)*sizeof(int));
                }
        }
        
        mcrypt_dlclose(_handle);
        if (lt_dlexit() != 0) {
                return NULL;
        }

        return ret_size;
}
1	nmav	1.1	/*
2	nmav	1.20	* Copyright (C) 1998,1999,2000,2001 Nikos Mavroyanopoulos
3	nmav	1.1	*
4			* This library is free software; you can redistribute it and/or modify it
5			* under the terms of the GNU Library General Public License as published
6			* by the Free Software Foundation; either version 2 of the License, or
7			* (at your option) any later version.
8			*
9			* This library is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Library General Public License for more details.
13			*
14			* You should have received a copy of the GNU Library General Public
15			* License along with this library; if not, write to the
16			* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17			* Boston, MA 02111-1307, USA.
18			*/
19
20			#ifndef LIBDEFS_H
21			#define LIBDEFS_H
22			#include <libdefs.h>
23			#endif
24			#include <bzero.h>
25			#include <mcrypt_internal.h>
26			#include <xmemory.h>
27
28	nmav	1.16	#ifndef DEBUG
29	nmav	1.17	# define fputs(x, y)
30	nmav	1.1	#endif
31
32	nmav	1.18	extern const mcrypt_preloaded mps[];
33	nmav	1.17
34			#define MAX_MOD_SIZE 1024
35
36	nmav	1.19	static int mcrypt_strcmp( const char* str1, const char* str2) {
37			int i;
38			int len;
39			if (strlen(str1)!=strlen(str2)) return -1;
40			len = strlen(str1);
41
42			for (i=0;i<len;i++) {
43			if (str1[i]=='_' && str2[i]=='-') continue;
44			if (str2[i]=='_' && str1[i]=='-') continue;
45			if (str1[i]!=str2[i]) return -1;
46			}
47
48			return 0;
49			}
50
51	nmav	1.20	lt_ptr _mcrypt_search_symlist_lib(const char* name) {
52	nmav	1.17	int i=0;
53
54	nmav	1.18	while( mps[i].name!=0 \|\| mps[i].address!=0) {
55			if (mps[i].name!=NULL && mps[i].address==NULL) {
56	nmav	1.19	if (mcrypt_strcmp(name, mps[i].name)==0) {
57	nmav	1.17	return (void*) -1;
58			}
59			}
60			i++;
61			}
62			return NULL;
63			}
64
65	nmav	1.20	lt_ptr _mcrypt_search_symlist_sym(mcrypt_dlhandle handle, const char* _name) {
66	nmav	1.17	int i=0;
67			char name[MAX_MOD_SIZE];
68
69			strcpy(name, handle.name);
70
71			strcat( name, "_LTX_");
72			strcat( name, _name);
73
74	nmav	1.18	while( mps[i].name!=0 \|\| mps[i].address!=0) {
75			if (mps[i].name!=NULL) {
76	nmav	1.19	if (mcrypt_strcmp(name, mps[i].name)==0) {
77	nmav	1.18	return mps[i].address;
78	nmav	1.17	}
79			}
80			i++;
81			}
82			return NULL;
83			}
84
85			void mcrypt_dlclose( mcrypt_dlhandle handle) {
86			void* mod = handle.handle;
87
88			if (mod!=MCRYPT_INTERNAL_HANDLER && mod!=NULL)
89			lt_dlclose(mod);
90			handle.handle = NULL;
91			}
92
93			lt_ptr mcrypt_dlsym( mcrypt_dlhandle handle, char* str) {
94			void* mod;
95
96			mod = handle.handle;
97
98			if (mod!=MCRYPT_INTERNAL_HANDLER)
99			return lt_dlsym(mod, str);
100			else
101	nmav	1.20	return _mcrypt_search_symlist_sym(handle, str);
102	nmav	1.17
103			}
104
105	nmav	1.5	WIN32DLL_DEFINE
106	nmav	1.1	int mcrypt_module_close(MCRYPT td)
107			{
108	nmav	1.17	mcrypt_dlclose(td->algorithm_handle);
109			mcrypt_dlclose(td->mode_handle);
110	nmav	1.15	if (lt_dlexit() != 0) {
111			return MCRYPT_UNKNOWN_ERROR;
112			}
113	nmav	1.1
114			td->m_encrypt = NULL;
115			td->a_encrypt = NULL;
116			td->a_decrypt = NULL;
117			td->m_decrypt = NULL;
118
119	nmav	1.13	free(td);
120
121	nmav	1.1	return 0;
122			}
123
124	nmav	1.17
125	nmav	1.5	WIN32DLL_DEFINE
126	nmav	1.17	void* mcrypt_dlopen ( mcrypt_dlhandle* handle, const char* a_directory, const char m_directory, const char filename) {
127
128			char paths[1526];
129	nmav	1.2
130	nmav	1.17	if (strlen(filename) > sizeof( handle->name))
131			return MCRYPT_FAILED;
132			else
133			strcpy( handle->name, filename);
134
135	nmav	1.20	if (_mcrypt_search_symlist_lib(filename)!=NULL) {
136	nmav	1.17	handle->handle = MCRYPT_INTERNAL_HANDLER;
137			return handle->handle;
138	nmav	1.2	}
139
140	nmav	1.3	memset( paths, 0, 1024);
141			if (a_directory != NULL) {
142			strncat( paths, a_directory, 512);
143			strcat( paths, ":");
144			}
145			if (m_directory != NULL) {
146			strncat( paths, m_directory, 512);
147			strcat( paths, ":");
148			}
149			strncat( paths, LIBDIR, 512);
150
151			lt_dlsetsearchpath(paths);
152	nmav	1.2
153	nmav	1.17	handle->handle = lt_dlopenext(filename);
154	nmav	1.3
155	nmav	1.17	return handle->handle;
156	nmav	1.2
157			}
158
159	nmav	1.5	WIN32DLL_DEFINE
160	nmav	1.1	MCRYPT mcrypt_module_open(char *algorithm,
161			char a_directory, char mode, char *m_directory)
162			{
163			MCRYPT td;
164	nmav	1.8	const char* err;
165	nmav	1.17	void *ret;
166	nmav	1.2
167	nmav	1.1	td = calloc(1, sizeof(CRYPT_STREAM));
168	nmav	1.10	if (td==NULL) return MCRYPT_FAILED;
169	nmav	1.1
170			if (lt_dlinit() != 0) {
171			return MCRYPT_FAILED;
172			}
173
174	nmav	1.17	ret = mcrypt_dlopen( &td->algorithm_handle, a_directory, m_directory, algorithm);
175			if (ret == NULL) {
176	nmav	1.4	err=lt_dlerror();
177			if (err!=NULL) fputs( err, stderr);
178	nmav	1.1	fputs("\n", stderr);
179	nmav	1.17	free(td);
180	nmav	1.1	return MCRYPT_FAILED;
181			}
182
183	nmav	1.17	ret = mcrypt_dlopen( &td->mode_handle, a_directory, m_directory, mode);
184	nmav	1.1
185	nmav	1.17	if (ret == NULL) {
186	nmav	1.4	err=lt_dlerror();
187			if (err!=NULL) fputs( err, stderr);
188	nmav	1.17	mcrypt_dlclose(td->algorithm_handle);
189			free(td);
190	nmav	1.1	return MCRYPT_FAILED;
191			}
192
193	nmav	1.17	td->a_encrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_encrypt");
194			td->a_decrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_decrypt");
195			td->m_encrypt = mcrypt_dlsym(td->mode_handle, "_mcrypt");
196			td->m_decrypt = mcrypt_dlsym(td->mode_handle, "_mdecrypt");
197	nmav	1.1	td->a_block_size =
198	nmav	1.17	mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_block_size");
199	nmav	1.1
200			if (mcrypt_enc_is_block_algorithm_mode(td) !=
201			mcrypt_enc_is_block_algorithm(td)) {
202			mcrypt_module_close(td);
203			return MCRYPT_FAILED;
204			}
205
206			return td;
207			}
208
209
210
211			/* Modules' frontends */
212
213	nmav	1.5	WIN32DLL_DEFINE
214	nmav	1.1	int mcrypt_get_size(MCRYPT td)
215			{
216			int (*_mcrypt_get_size) (void);
217
218			const char *error;
219
220	nmav	1.17	_mcrypt_get_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_size");
221	nmav	1.15	if (_mcrypt_get_size == NULL) {
222			error = lt_dlerror();
223	nmav	1.4	if (error!=NULL) fputs(error, stderr);
224	nmav	1.1	fputs("\n", stderr);
225			return MCRYPT_UNKNOWN_ERROR;
226			}
227			return _mcrypt_get_size();
228			}
229
230	nmav	1.5	WIN32DLL_DEFINE
231	nmav	1.1	int mcrypt_mode_get_size(MCRYPT td)
232			{
233			int (*_mcrypt_get_size) (void);
234
235			const char *error;
236
237	nmav	1.17	_mcrypt_get_size = mcrypt_dlsym(td->mode_handle, "_mcrypt_mode_get_size");
238	nmav	1.15	if (_mcrypt_get_size == NULL) {
239			error = lt_dlerror();
240	nmav	1.4	if (error!=NULL) fputs(error, stderr);
241	nmav	1.1	fputs("\n", stderr);
242			return MCRYPT_UNKNOWN_ERROR;
243			}
244			return _mcrypt_get_size();
245			}
246
247	nmav	1.5	WIN32DLL_DEFINE
248	nmav	1.9	int mcrypt_set_key(MCRYPT td, void a, void b, int c, void *d, int e)
249	nmav	1.1	{
250	nmav	1.9	int (__mcrypt_set_key_stream) (void , void , int, void , int);
251			int (__mcrypt_set_key_block) (void , void *, int);
252	nmav	1.1	const char *error;
253
254			if (mcrypt_enc_is_block_algorithm(td) == 0) {
255			/* stream */
256	nmav	1.17	__mcrypt_set_key_stream = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
257	nmav	1.15	if (__mcrypt_set_key_stream == NULL) {
258			error = lt_dlerror();
259	nmav	1.4	if (error!=NULL) fputs(error, stderr);
260	nmav	1.1	fputs("\n", stderr);
261	nmav	1.9	return -2;
262	nmav	1.1	}
263	nmav	1.9	return __mcrypt_set_key_stream(a, b, c, d, e);
264	nmav	1.1	} else {
265	nmav	1.17	__mcrypt_set_key_block = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
266	nmav	1.15	if (__mcrypt_set_key_block == NULL) {
267			error = lt_dlerror();
268	nmav	1.4	if (error!=NULL) fputs(error, stderr);
269	nmav	1.1	fputs("\n", stderr);
270	nmav	1.9	return -2;
271	nmav	1.1	}
272	nmav	1.9	return __mcrypt_set_key_block(a, b, c);
273	nmav	1.1	}
274			}
275
276	nmav	1.5	WIN32DLL_DEFINE
277	nmav	1.2	int mcrypt_enc_set_state(MCRYPT td, void *iv, int size)
278			{
279			int (__mcrypt_set_state) (void , void *, int);
280			const char *error;
281
282	nmav	1.17	__mcrypt_set_state = mcrypt_dlsym(td->mode_handle, "_mcrypt_set_state");
283	nmav	1.15	if (__mcrypt_set_state==NULL) {
284			error = lt_dlerror();
285	nmav	1.4	if (error!=NULL) fputs(error, stderr);
286	nmav	1.2	fputs("\n", stderr);
287			return MCRYPT_UNKNOWN_ERROR;
288			}
289			return __mcrypt_set_state(td->abuf, iv, size);
290			}
291
292	nmav	1.5	WIN32DLL_DEFINE
293	nmav	1.1	int mcrypt_enc_get_block_size(MCRYPT td)
294			{
295			int (*_mcrypt_get_block_size) (void);
296
297			_mcrypt_get_block_size = td->a_block_size;
298			return _mcrypt_get_block_size();
299			}
300
301	nmav	1.5	WIN32DLL_DEFINE
302	nmav	1.1	int mcrypt_get_algo_iv_size(MCRYPT td)
303			{
304			int (*_mcrypt_get_algo_iv_size) (void);
305
306	nmav	1.17	_mcrypt_get_algo_iv_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algo_iv_size");
307	nmav	1.1	return _mcrypt_get_algo_iv_size();
308			}
309
310	nmav	1.5	WIN32DLL_DEFINE
311	nmav	1.1	int mcrypt_enc_get_iv_size(MCRYPT td)
312			{
313			if (mcrypt_enc_is_block_algorithm_mode(td) == 1) {
314			return mcrypt_enc_get_block_size(td);
315			} else {
316			return mcrypt_get_algo_iv_size(td);
317			}
318			}
319
320	nmav	1.5	WIN32DLL_DEFINE
321	nmav	1.1	int mcrypt_enc_get_key_size(MCRYPT td)
322			{
323			int (*_mcrypt_get_key_size) (void);
324
325	nmav	1.17	_mcrypt_get_key_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_key_size");
326	nmav	1.1	return _mcrypt_get_key_size();
327			}
328
329	nmav	1.5	WIN32DLL_DEFINE
330	nmav	1.21	const int mcrypt_enc_get_supported_key_sizes(MCRYPT td, int len)
331	nmav	1.1	{
332			int (_mcrypt_get_key_sizes) (int *);
333			int *size;
334
335			_mcrypt_get_key_sizes =
336	nmav	1.17	mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_supported_key_sizes");
337	nmav	1.1	size = _mcrypt_get_key_sizes(len);
338
339			return size;
340			}
341
342	nmav	1.5	WIN32DLL_DEFINE
343	nmav	1.1	int mcrypt_enc_is_block_algorithm(MCRYPT td)
344			{
345			int (*_is_block_algorithm) (void);
346
347	nmav	1.17	_is_block_algorithm = mcrypt_dlsym(td->algorithm_handle, "_is_block_algorithm");
348	nmav	1.1	return _is_block_algorithm();
349			}
350
351	nmav	1.5	WIN32DLL_DEFINE
352	nmav	1.20	const char *mcrypt_enc_get_algorithms_name(MCRYPT td)
353	nmav	1.1	{
354	nmav	1.20	const char (_mcrypt_get_algorithms_name) (void);
355	nmav	1.1
356			_mcrypt_get_algorithms_name =
357	nmav	1.17	mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algorithms_name");
358	nmav	1.1	return _mcrypt_get_algorithms_name();
359			}
360
361	nmav	1.5	WIN32DLL_DEFINE
362	nmav	1.1	int init_mcrypt(MCRYPT td, void buf, void a, int b, void *c)
363			{
364			int (_init_mcrypt) (void , void , int, void , int);
365
366	nmav	1.17	_init_mcrypt = mcrypt_dlsym(td->mode_handle, "_init_mcrypt");
367	nmav	1.1	return _init_mcrypt(buf, a, b, c, mcrypt_enc_get_block_size(td));
368			}
369
370	nmav	1.5	WIN32DLL_DEFINE
371	nmav	1.1	int end_mcrypt(MCRYPT td, void *buf)
372			{
373			int (_end_mcrypt) (void );
374
375	nmav	1.17	_end_mcrypt = mcrypt_dlsym(td->mode_handle, "_end_mcrypt");
376	nmav	1.1	return _end_mcrypt(buf);
377			}
378
379	nmav	1.5	WIN32DLL_DEFINE
380	nmav	1.1	int mcrypt(MCRYPT td, void buf, void a, int b)
381			{
382			int (_mcrypt) (void , void , int, int, void , void , void);
383			_mcrypt = td->m_encrypt;
384
385			return _mcrypt(buf, a, b, mcrypt_enc_get_block_size(td), td->akey,
386			td->a_encrypt, td->a_decrypt);
387			}
388
389	nmav	1.5	WIN32DLL_DEFINE
390	nmav	1.1	int mdecrypt(MCRYPT td, void buf, void a, int b)
391			{
392			int (_mdecrypt) (void , void , int, int, void , void , void);
393
394			_mdecrypt = td->m_decrypt;
395			return _mdecrypt(buf, a, b, mcrypt_enc_get_block_size(td),
396			td->akey, td->a_encrypt, td->a_decrypt);
397			}
398
399	nmav	1.5	WIN32DLL_DEFINE
400	nmav	1.20	const char *mcrypt_enc_get_modes_name(MCRYPT td)
401	nmav	1.1	{
402	nmav	1.20	const char (_mcrypt_get_modes_name) (void);
403	nmav	1.1
404	nmav	1.17	_mcrypt_get_modes_name = mcrypt_dlsym(td->mode_handle, "_mcrypt_get_modes_name");
405	nmav	1.1	return _mcrypt_get_modes_name();
406			}
407
408	nmav	1.5	WIN32DLL_DEFINE
409	nmav	1.1	int mcrypt_enc_is_block_mode(MCRYPT td)
410			{
411			int (*_is_block_mode) (void);
412
413	nmav	1.17	_is_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_mode");
414	nmav	1.1	return _is_block_mode();
415			}
416
417	nmav	1.5	WIN32DLL_DEFINE
418	nmav	1.1	int mcrypt_enc_mode_has_iv(MCRYPT td)
419			{
420			int (*_has_iv) (void);
421
422	nmav	1.17	_has_iv = mcrypt_dlsym(td->mode_handle, "_has_iv");
423	nmav	1.1	return _has_iv();
424			}
425
426	nmav	1.5	WIN32DLL_DEFINE
427	nmav	1.1	int mcrypt_enc_is_block_algorithm_mode(MCRYPT td)
428			{
429			int (*_is_a_block_mode) (void);
430
431	nmav	1.17	_is_a_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_algorithm_mode");
432	nmav	1.1	return _is_a_block_mode();
433			}
434
435	nmav	1.5	WIN32DLL_DEFINE
436	nmav	1.1	int mcrypt_enc_self_test(MCRYPT td)
437			{
438			int (*_self_test) (void);
439
440	nmav	1.17	_self_test = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_self_test");
441	nmav	1.1
442			return _self_test();
443			}
444
445	nmav	1.5	WIN32DLL_DEFINE
446	nmav	1.1	int mcrypt_module_self_test(char algorithm, char a_directory)
447			{
448			int i;
449	nmav	1.17	void* rr;
450			mcrypt_dlhandle _handle;
451	nmav	1.1	int (*_self_test) (void);
452	nmav	1.8	const char* error;
453	nmav	1.1
454			if (lt_dlinit() != 0) {
455			return MCRYPT_UNKNOWN_ERROR;
456			}
457
458	nmav	1.17	rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);
459	nmav	1.1
460	nmav	1.17	if (!rr) {
461	nmav	1.4	error=lt_dlerror();
462			if (error!=NULL) fputs( error, stderr);
463	nmav	1.1	fputs("\n", stderr);
464	nmav	1.15	lt_dlexit();
465	nmav	1.1	return MCRYPT_UNKNOWN_ERROR;
466			}
467
468	nmav	1.17	_self_test = mcrypt_dlsym(_handle, "_mcrypt_self_test");
469	nmav	1.1
470			i = _self_test();
471
472	nmav	1.17	mcrypt_dlclose(_handle);
473	nmav	1.15	if (lt_dlexit() != 0) {
474			return MCRYPT_UNKNOWN_ERROR;
475			}
476
477	nmav	1.1	return i;
478			}
479
480	nmav	1.5	WIN32DLL_DEFINE
481	nmav	1.1	int mcrypt_module_algorithm_version(char algorithm, char a_directory)
482			{
483			int i;
484	nmav	1.17	mcrypt_dlhandle _handle;
485	nmav	1.1	int (*_version) (void);
486	nmav	1.8	const char* error;
487	nmav	1.17	void* rr;
488
489	nmav	1.1	if (lt_dlinit() != 0) {
490			return MCRYPT_UNKNOWN_ERROR;
491			}
492
493	nmav	1.17	rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);
494			if (!rr) {
495	nmav	1.4	error=lt_dlerror();
496			if (error!=NULL) fputs( error, stderr);
497	nmav	1.1	fputs("\n", stderr);
498			return MCRYPT_UNKNOWN_ERROR;
499			}
500
501	nmav	1.17	_version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");
502	nmav	1.1
503			i = _version();
504
505	nmav	1.17	mcrypt_dlclose(_handle);
506	nmav	1.15	if (lt_dlexit() != 0) {
507			return MCRYPT_UNKNOWN_ERROR;
508			}
509	nmav	1.1
510			return i;
511			}
512
513	nmav	1.5	WIN32DLL_DEFINE
514	nmav	1.1	int mcrypt_module_mode_version(char mode, char m_directory)
515			{
516			int i;
517	nmav	1.17	mcrypt_dlhandle _handle;
518	nmav	1.1	int (*_version) (void);
519	nmav	1.8	const char* error;
520	nmav	1.17	void * rr;
521	nmav	1.1
522			if (lt_dlinit() != 0) {
523			return MCRYPT_UNKNOWN_ERROR;
524			}
525
526	nmav	1.17	rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
527			if (!rr) {
528	nmav	1.4	error=lt_dlerror();
529			if(error!=NULL) fputs(error, stderr);
530	nmav	1.1	fputs("\n", stderr);
531			return MCRYPT_UNKNOWN_ERROR;
532			}
533
534	nmav	1.17	_version = mcrypt_dlsym( _handle, "_mcrypt_mode_version");
535	nmav	1.1
536			i = _version();
537
538	nmav	1.17	mcrypt_dlclose(_handle);
539	nmav	1.15	if (lt_dlexit() != 0) {
540			return MCRYPT_UNKNOWN_ERROR;
541			}
542	nmav	1.1
543			return i;
544			}
545
546	nmav	1.5	WIN32DLL_DEFINE
547	nmav	1.1	int mcrypt_module_is_block_algorithm(char algorithm, char a_directory)
548			{
549			int i;
550	nmav	1.17	mcrypt_dlhandle _handle;
551	nmav	1.1	int (*_is_block_algorithm) (void);
552	nmav	1.8	const char* error;
553	nmav	1.17	void * rr;
554	nmav	1.4
555	nmav	1.1	if (lt_dlinit() != 0) {
556			return MCRYPT_UNKNOWN_ERROR;
557			}
558
559	nmav	1.17	rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
560			if (!rr) {
561	nmav	1.4	error=lt_dlerror();
562			if(error!=NULL) fputs( error, stderr);
563	nmav	1.1	fputs("\n", stderr);
564			return MCRYPT_UNKNOWN_ERROR;
565			}
566
567	nmav	1.17	_is_block_algorithm = mcrypt_dlsym(_handle, "_is_block_algorithm");
568	nmav	1.1
569			i = _is_block_algorithm();
570
571	nmav	1.17	mcrypt_dlclose(_handle);
572	nmav	1.15	if (lt_dlexit() != 0) {
573			return MCRYPT_UNKNOWN_ERROR;
574			}
575	nmav	1.1
576			return i;
577			}
578
579	nmav	1.5	WIN32DLL_DEFINE
580	nmav	1.1	int mcrypt_module_is_block_algorithm_mode(char mode, char m_directory)
581			{
582			int i;
583	nmav	1.17	mcrypt_dlhandle _handle;
584	nmav	1.1	int (*_is_a_block_mode) (void);
585	nmav	1.8	const char* error;
586	nmav	1.17	void * rr;
587	nmav	1.1
588			if (lt_dlinit() != 0) {
589			return MCRYPT_UNKNOWN_ERROR;
590			}
591
592	nmav	1.17	rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
593			if (!rr) {
594	nmav	1.4	error=lt_dlerror();
595			if(error!=NULL) fputs( error, stderr);
596	nmav	1.1	fputs("\n", stderr);
597			return MCRYPT_UNKNOWN_ERROR;
598			}
599
600	nmav	1.17	_is_a_block_mode = mcrypt_dlsym(_handle, "_is_block_algorithm_mode");
601	nmav	1.1
602			i = _is_a_block_mode();
603
604	nmav	1.17	mcrypt_dlclose(_handle);
605	nmav	1.15	if (lt_dlexit() != 0) {
606			return MCRYPT_UNKNOWN_ERROR;
607			}
608	nmav	1.1
609			return i;
610			}
611
612	nmav	1.5	WIN32DLL_DEFINE
613	nmav	1.1	int mcrypt_module_is_block_mode(char mode, char m_directory)
614			{
615	nmav	1.17	void * rr;
616	nmav	1.1	int i;
617	nmav	1.17	mcrypt_dlhandle _handle;
618	nmav	1.1	int (*_is_block_mode) (void);
619	nmav	1.8	const char* error;
620	nmav	1.1
621			if (lt_dlinit() != 0) {
622			return MCRYPT_UNKNOWN_ERROR;
623			}
624
625	nmav	1.17	rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
626			if (!rr) {
627	nmav	1.4	error=lt_dlerror();
628			if(error!=NULL) fputs( error, stderr);
629	nmav	1.1	fputs("\n", stderr);
630			return MCRYPT_UNKNOWN_ERROR;
631			}
632
633	nmav	1.17	_is_block_mode = mcrypt_dlsym(_handle, "_is_block_mode");
634	nmav	1.1
635			i = _is_block_mode();
636
637	nmav	1.17	mcrypt_dlclose(_handle);
638	nmav	1.15	if (lt_dlexit() != 0) {
639			return MCRYPT_UNKNOWN_ERROR;
640			}
641	nmav	1.1
642			return i;
643			}
644
645	nmav	1.5	WIN32DLL_DEFINE
646	nmav	1.1	int mcrypt_module_get_algo_block_size(char algorithm, char a_directory)
647			{
648			int i;
649	nmav	1.17	mcrypt_dlhandle _handle;
650	nmav	1.1	int (*_get_block_size) (void);
651	nmav	1.8	const char* error;
652	nmav	1.17	void * rr;
653	nmav	1.1
654			if (lt_dlinit() != 0) {
655			return MCRYPT_UNKNOWN_ERROR;
656			}
657
658	nmav	1.17	rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
659			if (!rr) {
660	nmav	1.4	error=lt_dlerror();
661			if(error!=NULL) fputs( error, stderr);
662	nmav	1.1	fputs("\n", stderr);
663			return MCRYPT_UNKNOWN_ERROR;
664			}
665
666	nmav	1.17	_get_block_size = mcrypt_dlsym(_handle, "_mcrypt_get_block_size");
667	nmav	1.1
668			i = _get_block_size();
669
670	nmav	1.17	mcrypt_dlclose(_handle);
671	nmav	1.15	if (lt_dlexit() != 0) {
672			return MCRYPT_UNKNOWN_ERROR;
673			}
674	nmav	1.1
675			return i;
676			}
677
678	nmav	1.5	WIN32DLL_DEFINE
679	nmav	1.1	int mcrypt_module_get_algo_key_size(char algorithm, char a_directory)
680			{
681			int i;
682	nmav	1.17	mcrypt_dlhandle _handle;
683	nmav	1.1	int (*_get_key_size) (void);
684	nmav	1.8	const char* error;
685	nmav	1.17	void * rr;
686	nmav	1.1
687			if (lt_dlinit() != 0) {
688			return MCRYPT_UNKNOWN_ERROR;
689			}
690
691	nmav	1.17	rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
692			if (!rr) {
693	nmav	1.4	error=lt_dlerror();
694			if(error!=NULL) fputs( error, stderr);
695	nmav	1.1	fputs("\n", stderr);
696			return MCRYPT_UNKNOWN_ERROR;
697			}
698
699	nmav	1.17	_get_key_size = mcrypt_dlsym(_handle, "_mcrypt_get_key_size");
700	nmav	1.1
701			i = _get_key_size();
702
703	nmav	1.17	mcrypt_dlclose(_handle);
704	nmav	1.15	if (lt_dlexit() != 0) {
705			return MCRYPT_UNKNOWN_ERROR;
706			}
707	nmav	1.1
708			return i;
709			}
710
711	nmav	1.5	WIN32DLL_DEFINE
712	nmav	1.1	int mcrypt_module_get_algo_supported_key_sizes(char algorithm,
713			char *a_directory,
714			int *len)
715			{
716	nmav	1.17	mcrypt_dlhandle _handle;
717	nmav	1.1	int (_mcrypt_get_key_sizes) (int *);
718			int *size;
719	nmav	1.21	int * ret_size;
720	nmav	1.8	const char* error;
721	nmav	1.17	void * rr;
722
723	nmav	1.1	if (lt_dlinit() != 0) {
724			*len = 0;
725			return NULL;
726			}
727
728	nmav	1.17	rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
729			if (!rr) {
730	nmav	1.4	error=lt_dlerror();
731			if(error!=NULL) fputs( error, stderr);
732	nmav	1.1	fputs("\n", stderr);
733			*len = 0;
734			return NULL;
735			}
736
737			_mcrypt_get_key_sizes =
738	nmav	1.17	mcrypt_dlsym(_handle, "_mcrypt_get_supported_key_sizes");
739	nmav	1.1
740			size = _mcrypt_get_key_sizes(len);
741	nmav	1.21	if (len!=0) {
742			ret_size = malloc( (len)sizeof(int));
743			if (ret_size!=NULL) {
744			memcpy( ret_size, size, (len)sizeof(int));
745			}
746			}
747
748	nmav	1.17	mcrypt_dlclose(_handle);
749	nmav	1.15	if (lt_dlexit() != 0) {
750			return NULL;
751			}
752	nmav	1.1
753	nmav	1.21	return ret_size;
754	nmav	1.1	}