/[mcrypt]/libmcrypt/lib/mcrypt_modules.c
ViewVC logotype

Annotation of /libmcrypt/lib/mcrypt_modules.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.25 - (hide annotations)
Sat Dec 15 11:27:34 2001 UTC (22 years, 4 months ago) by nmav
Branch: MAIN
Changes since 1.24: +244 -34 lines
File MIME type: text/plain 
cleanups in the code. Some fixes too. Patch by Barton C Massey
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.22 if (td==NULL) return MCRYPT_UNKNOWN_ERROR;
109    
110 nmav 1.17 mcrypt_dlclose(td->algorithm_handle);
111     mcrypt_dlclose(td->mode_handle);
112 nmav 1.15 if (lt_dlexit() != 0) {
113     return MCRYPT_UNKNOWN_ERROR;
114     }
115 nmav 1.1
116     td->m_encrypt = NULL;
117     td->a_encrypt = NULL;
118     td->a_decrypt = NULL;
119     td->m_decrypt = NULL;
120    
121 nmav 1.13 free(td);
122    
123 nmav 1.1 return 0;
124     }
125    
126 nmav 1.17
127 nmav 1.5 WIN32DLL_DEFINE
128 nmav 1.17 void* mcrypt_dlopen ( mcrypt_dlhandle* handle, const char* a_directory, const char *m_directory, const char *filename) {
129    
130     char paths[1526];
131 nmav 1.2
132 nmav 1.17 if (strlen(filename) > sizeof( handle->name))
133     return MCRYPT_FAILED;
134     else
135     strcpy( handle->name, filename);
136    
137 nmav 1.20 if (_mcrypt_search_symlist_lib(filename)!=NULL) {
138 nmav 1.17 handle->handle = MCRYPT_INTERNAL_HANDLER;
139     return handle->handle;
140 nmav 1.2 }
141    
142 nmav 1.3 memset( paths, 0, 1024);
143     if (a_directory != NULL) {
144     strncat( paths, a_directory, 512);
145     strcat( paths, ":");
146     }
147     if (m_directory != NULL) {
148     strncat( paths, m_directory, 512);
149     strcat( paths, ":");
150     }
151     strncat( paths, LIBDIR, 512);
152    
153     lt_dlsetsearchpath(paths);
154 nmav 1.2
155 nmav 1.17 handle->handle = lt_dlopenext(filename);
156 nmav 1.3
157 nmav 1.17 return handle->handle;
158 nmav 1.2
159     }
160    
161 nmav 1.5 WIN32DLL_DEFINE
162 nmav 1.1 MCRYPT mcrypt_module_open(char *algorithm,
163     char *a_directory, char *mode, char *m_directory)
164     {
165     MCRYPT td;
166 nmav 1.8 const char* err;
167 nmav 1.17 void *ret;
168 nmav 1.2
169 nmav 1.1 td = calloc(1, sizeof(CRYPT_STREAM));
170 nmav 1.10 if (td==NULL) return MCRYPT_FAILED;
171 nmav 1.1
172     if (lt_dlinit() != 0) {
173     return MCRYPT_FAILED;
174     }
175    
176 nmav 1.17 ret = mcrypt_dlopen( &td->algorithm_handle, a_directory, m_directory, algorithm);
177     if (ret == NULL) {
178 nmav 1.4 err=lt_dlerror();
179 nmav 1.25 if (err!=NULL) {
180     fputs( err, stderr);
181     fputs("\n", stderr);
182     }
183 nmav 1.17 free(td);
184 nmav 1.1 return MCRYPT_FAILED;
185     }
186    
187 nmav 1.17 ret = mcrypt_dlopen( &td->mode_handle, a_directory, m_directory, mode);
188 nmav 1.1
189 nmav 1.17 if (ret == NULL) {
190 nmav 1.4 err=lt_dlerror();
191 nmav 1.25 if (err!=NULL) {
192     fputs( err, stderr);
193     fputs( "\n", stderr);
194     }
195 nmav 1.17 mcrypt_dlclose(td->algorithm_handle);
196     free(td);
197 nmav 1.1 return MCRYPT_FAILED;
198     }
199    
200 nmav 1.17 td->a_encrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_encrypt");
201     td->a_decrypt = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_decrypt");
202     td->m_encrypt = mcrypt_dlsym(td->mode_handle, "_mcrypt");
203     td->m_decrypt = mcrypt_dlsym(td->mode_handle, "_mdecrypt");
204 nmav 1.1 td->a_block_size =
205 nmav 1.17 mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_block_size");
206 nmav 1.1
207 nmav 1.25 if (td->a_encrypt == NULL || td->a_decrypt == NULL|| td->m_encrypt == NULL||
208     td->m_decrypt == NULL|| td->a_block_size == NULL) {
209     err=lt_dlerror();
210     if (err!=NULL) {
211     fputs( err, stderr);
212     fputs( "\n", stderr);
213     }
214     mcrypt_dlclose(td->algorithm_handle);
215     free(td);
216     return MCRYPT_FAILED;
217     }
218    
219 nmav 1.1 if (mcrypt_enc_is_block_algorithm_mode(td) !=
220     mcrypt_enc_is_block_algorithm(td)) {
221     mcrypt_module_close(td);
222 nmav 1.25 free(td);
223 nmav 1.1 return MCRYPT_FAILED;
224     }
225    
226     return td;
227     }
228    
229    
230    
231     /* Modules' frontends */
232    
233 nmav 1.5 WIN32DLL_DEFINE
234 nmav 1.1 int mcrypt_get_size(MCRYPT td)
235     {
236     int (*_mcrypt_get_size) (void);
237    
238     const char *error;
239    
240 nmav 1.17 _mcrypt_get_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_size");
241 nmav 1.15 if (_mcrypt_get_size == NULL) {
242     error = lt_dlerror();
243 nmav 1.25 if (error!=NULL) {
244     fputs(error, stderr);
245     fputs("\n", stderr);
246     }
247 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
248     }
249     return _mcrypt_get_size();
250     }
251    
252 nmav 1.5 WIN32DLL_DEFINE
253 nmav 1.1 int mcrypt_mode_get_size(MCRYPT td)
254     {
255     int (*_mcrypt_get_size) (void);
256    
257     const char *error;
258    
259 nmav 1.17 _mcrypt_get_size = mcrypt_dlsym(td->mode_handle, "_mcrypt_mode_get_size");
260 nmav 1.15 if (_mcrypt_get_size == NULL) {
261     error = lt_dlerror();
262 nmav 1.25 if (error!=NULL) {
263     fputs(error, stderr);
264     fputs("\n", stderr);
265     }
266 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
267     }
268     return _mcrypt_get_size();
269     }
270    
271 nmav 1.5 WIN32DLL_DEFINE
272 nmav 1.9 int mcrypt_set_key(MCRYPT td, void *a, void *b, int c, void *d, int e)
273 nmav 1.1 {
274 nmav 1.9 int (*__mcrypt_set_key_stream) (void *, void *, int, void *, int);
275     int (*__mcrypt_set_key_block) (void *, void *, int);
276 nmav 1.1 const char *error;
277    
278     if (mcrypt_enc_is_block_algorithm(td) == 0) {
279     /* stream */
280 nmav 1.17 __mcrypt_set_key_stream = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
281 nmav 1.15 if (__mcrypt_set_key_stream == NULL) {
282     error = lt_dlerror();
283 nmav 1.25 if (error!=NULL) {
284     fputs(error, stderr);
285     fputs("\n", stderr);
286     }
287 nmav 1.9 return -2;
288 nmav 1.1 }
289 nmav 1.9 return __mcrypt_set_key_stream(a, b, c, d, e);
290 nmav 1.1 } else {
291 nmav 1.17 __mcrypt_set_key_block = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_set_key");
292 nmav 1.15 if (__mcrypt_set_key_block == NULL) {
293     error = lt_dlerror();
294 nmav 1.25 if (error!=NULL) {
295     fputs(error, stderr);
296     fputs("\n", stderr);
297     }
298 nmav 1.9 return -2;
299 nmav 1.1 }
300 nmav 1.9 return __mcrypt_set_key_block(a, b, c);
301 nmav 1.1 }
302     }
303    
304 nmav 1.5 WIN32DLL_DEFINE
305 nmav 1.2 int mcrypt_enc_set_state(MCRYPT td, void *iv, int size)
306     {
307     int (*__mcrypt_set_state) (void *, void *, int);
308     const char *error;
309    
310 nmav 1.17 __mcrypt_set_state = mcrypt_dlsym(td->mode_handle, "_mcrypt_set_state");
311 nmav 1.15 if (__mcrypt_set_state==NULL) {
312     error = lt_dlerror();
313 nmav 1.25 if (error!=NULL) {
314     fputs(error, stderr);
315     fputs("\n", stderr);
316     }
317 nmav 1.2 return MCRYPT_UNKNOWN_ERROR;
318     }
319     return __mcrypt_set_state(td->abuf, iv, size);
320     }
321    
322 nmav 1.5 WIN32DLL_DEFINE
323 nmav 1.1 int mcrypt_enc_get_block_size(MCRYPT td)
324     {
325     int (*_mcrypt_get_block_size) (void);
326    
327     _mcrypt_get_block_size = td->a_block_size;
328     return _mcrypt_get_block_size();
329     }
330    
331 nmav 1.5 WIN32DLL_DEFINE
332 nmav 1.1 int mcrypt_get_algo_iv_size(MCRYPT td)
333     {
334 nmav 1.25 const char* error;
335 nmav 1.1 int (*_mcrypt_get_algo_iv_size) (void);
336    
337 nmav 1.17 _mcrypt_get_algo_iv_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algo_iv_size");
338 nmav 1.25 if (_mcrypt_get_algo_iv_size == NULL) {
339     error = lt_dlerror();
340     if (error!=NULL) {
341     fputs(error, stderr);
342     fputs("\n", stderr);
343     }
344     return MCRYPT_UNKNOWN_ERROR;
345     }
346 nmav 1.1 return _mcrypt_get_algo_iv_size();
347     }
348    
349 nmav 1.5 WIN32DLL_DEFINE
350 nmav 1.1 int mcrypt_enc_get_iv_size(MCRYPT td)
351     {
352     if (mcrypt_enc_is_block_algorithm_mode(td) == 1) {
353     return mcrypt_enc_get_block_size(td);
354     } else {
355     return mcrypt_get_algo_iv_size(td);
356     }
357     }
358    
359 nmav 1.5 WIN32DLL_DEFINE
360 nmav 1.1 int mcrypt_enc_get_key_size(MCRYPT td)
361     {
362 nmav 1.25 const char* error;
363 nmav 1.1 int (*_mcrypt_get_key_size) (void);
364    
365 nmav 1.17 _mcrypt_get_key_size = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_key_size");
366 nmav 1.25 if (_mcrypt_get_key_size == NULL) {
367     error = lt_dlerror();
368     if (error!=NULL) {
369     fputs(error, stderr);
370     fputs("\n", stderr);
371     }
372     return MCRYPT_UNKNOWN_ERROR;
373     }
374 nmav 1.1 return _mcrypt_get_key_size();
375     }
376    
377 nmav 1.5 WIN32DLL_DEFINE
378 nmav 1.23 int *mcrypt_enc_get_supported_key_sizes(MCRYPT td, int *len)
379 nmav 1.1 {
380     int *(*_mcrypt_get_key_sizes) (int *);
381 nmav 1.23 int *size, *ret;
382 nmav 1.25 const char* error;
383 nmav 1.1
384     _mcrypt_get_key_sizes =
385 nmav 1.17 mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_supported_key_sizes");
386 nmav 1.25 if (_mcrypt_get_key_sizes == NULL) {
387     error = lt_dlerror();
388     if (error!=NULL) {
389     fputs(error, stderr);
390     fputs("\n", stderr);
391     }
392     *len = 0;
393     return NULL;
394     }
395    
396 nmav 1.1 size = _mcrypt_get_key_sizes(len);
397 nmav 1.23
398     ret = NULL;
399 nmav 1.24 if (size!=NULL && (*len) != 0) {
400 nmav 1.23 ret = malloc( sizeof(int)*(*len));
401     if (ret==NULL) return NULL;
402     memcpy( ret, size, sizeof(int)*(*len));
403     }
404     return ret;
405 nmav 1.1 }
406    
407 nmav 1.5 WIN32DLL_DEFINE
408 nmav 1.1 int mcrypt_enc_is_block_algorithm(MCRYPT td)
409     {
410     int (*_is_block_algorithm) (void);
411 nmav 1.25 const char* error;
412 nmav 1.1
413 nmav 1.17 _is_block_algorithm = mcrypt_dlsym(td->algorithm_handle, "_is_block_algorithm");
414 nmav 1.25 if (_is_block_algorithm == NULL) {
415     error = lt_dlerror();
416     if (error!=NULL) {
417     fputs(error, stderr);
418     fputs("\n", stderr);
419     }
420     return MCRYPT_UNKNOWN_ERROR;
421     }
422    
423 nmav 1.1 return _is_block_algorithm();
424     }
425    
426 nmav 1.5 WIN32DLL_DEFINE
427 nmav 1.23 char *mcrypt_enc_get_algorithms_name(MCRYPT td)
428 nmav 1.1 {
429 nmav 1.20 const char *(*_mcrypt_get_algorithms_name) (void);
430 nmav 1.25 const char* error;
431 nmav 1.1
432     _mcrypt_get_algorithms_name =
433 nmav 1.17 mcrypt_dlsym(td->algorithm_handle, "_mcrypt_get_algorithms_name");
434 nmav 1.25 if (_mcrypt_get_algorithms_name == NULL) {
435     error = lt_dlerror();
436     if (error!=NULL) {
437     fputs(error, stderr);
438     fputs("\n", stderr);
439     }
440     return NULL;
441     }
442    
443 nmav 1.23 return strdup(_mcrypt_get_algorithms_name());
444 nmav 1.1 }
445    
446 nmav 1.5 WIN32DLL_DEFINE
447 nmav 1.1 int init_mcrypt(MCRYPT td, void *buf, void *a, int b, void *c)
448     {
449     int (*_init_mcrypt) (void *, void *, int, void *, int);
450 nmav 1.25 const char* error;
451 nmav 1.1
452 nmav 1.17 _init_mcrypt = mcrypt_dlsym(td->mode_handle, "_init_mcrypt");
453 nmav 1.25 if (_init_mcrypt == NULL) {
454     error = lt_dlerror();
455     if (error!=NULL) {
456     fputs(error, stderr);
457     fputs("\n", stderr);
458     }
459     return MCRYPT_UNKNOWN_ERROR;
460     }
461    
462 nmav 1.1 return _init_mcrypt(buf, a, b, c, mcrypt_enc_get_block_size(td));
463     }
464    
465 nmav 1.5 WIN32DLL_DEFINE
466 nmav 1.1 int end_mcrypt(MCRYPT td, void *buf)
467     {
468     int (*_end_mcrypt) (void *);
469 nmav 1.25 const char* error;
470 nmav 1.1
471 nmav 1.17 _end_mcrypt = mcrypt_dlsym(td->mode_handle, "_end_mcrypt");
472 nmav 1.25 if (_end_mcrypt == NULL) {
473     error = lt_dlerror();
474     if (error!=NULL) {
475     fputs(error, stderr);
476     fputs("\n", stderr);
477     }
478     return MCRYPT_UNKNOWN_ERROR;
479     }
480    
481 nmav 1.1 return _end_mcrypt(buf);
482     }
483    
484 nmav 1.5 WIN32DLL_DEFINE
485 nmav 1.1 int mcrypt(MCRYPT td, void *buf, void *a, int b)
486     {
487     int (*_mcrypt) (void *, void *, int, int, void *, void *, void*);
488     _mcrypt = td->m_encrypt;
489    
490     return _mcrypt(buf, a, b, mcrypt_enc_get_block_size(td), td->akey,
491     td->a_encrypt, td->a_decrypt);
492     }
493    
494 nmav 1.5 WIN32DLL_DEFINE
495 nmav 1.1 int mdecrypt(MCRYPT td, void *buf, void *a, int b)
496     {
497     int (*_mdecrypt) (void *, void *, int, int, void *, void *, void*);
498    
499     _mdecrypt = td->m_decrypt;
500     return _mdecrypt(buf, a, b, mcrypt_enc_get_block_size(td),
501     td->akey, td->a_encrypt, td->a_decrypt);
502     }
503    
504 nmav 1.5 WIN32DLL_DEFINE
505 nmav 1.23 char *mcrypt_enc_get_modes_name(MCRYPT td)
506 nmav 1.1 {
507 nmav 1.20 const char *(*_mcrypt_get_modes_name) (void);
508 nmav 1.25 const char* error;
509 nmav 1.1
510 nmav 1.17 _mcrypt_get_modes_name = mcrypt_dlsym(td->mode_handle, "_mcrypt_get_modes_name");
511 nmav 1.25 if (_mcrypt_get_modes_name == NULL) {
512     error = lt_dlerror();
513     if (error!=NULL) {
514     fputs(error, stderr);
515     fputs("\n", stderr);
516     }
517     return NULL;
518     }
519    
520 nmav 1.23 return strdup(_mcrypt_get_modes_name());
521 nmav 1.1 }
522    
523 nmav 1.5 WIN32DLL_DEFINE
524 nmav 1.1 int mcrypt_enc_is_block_mode(MCRYPT td)
525     {
526     int (*_is_block_mode) (void);
527 nmav 1.25 const char* error;
528    
529     _is_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_mode");
530     if (_is_block_mode == NULL) {
531     error = lt_dlerror();
532     if (error!=NULL) {
533     fputs(error, stderr);
534     fputs("\n", stderr);
535     }
536     return MCRYPT_UNKNOWN_ERROR;
537     }
538 nmav 1.1
539     return _is_block_mode();
540     }
541    
542 nmav 1.5 WIN32DLL_DEFINE
543 nmav 1.1 int mcrypt_enc_mode_has_iv(MCRYPT td)
544     {
545     int (*_has_iv) (void);
546 nmav 1.25 const char* error;
547 nmav 1.1
548 nmav 1.17 _has_iv = mcrypt_dlsym(td->mode_handle, "_has_iv");
549 nmav 1.25 if (_has_iv == NULL) {
550     error = lt_dlerror();
551     if (error!=NULL) {
552     fputs(error, stderr);
553     fputs("\n", stderr);
554     }
555     return MCRYPT_UNKNOWN_ERROR;
556     }
557    
558 nmav 1.1 return _has_iv();
559     }
560    
561 nmav 1.5 WIN32DLL_DEFINE
562 nmav 1.1 int mcrypt_enc_is_block_algorithm_mode(MCRYPT td)
563     {
564     int (*_is_a_block_mode) (void);
565 nmav 1.25 const char* error;
566 nmav 1.1
567 nmav 1.17 _is_a_block_mode = mcrypt_dlsym(td->mode_handle, "_is_block_algorithm_mode");
568 nmav 1.25 if (_is_a_block_mode == NULL) {
569     error = lt_dlerror();
570     if (error!=NULL) {
571     fputs(error, stderr);
572     fputs("\n", stderr);
573     }
574     return MCRYPT_UNKNOWN_ERROR;
575     }
576    
577 nmav 1.1 return _is_a_block_mode();
578     }
579    
580 nmav 1.5 WIN32DLL_DEFINE
581 nmav 1.1 int mcrypt_enc_self_test(MCRYPT td)
582     {
583     int (*_self_test) (void);
584 nmav 1.25 const char* error;
585 nmav 1.1
586 nmav 1.17 _self_test = mcrypt_dlsym(td->algorithm_handle, "_mcrypt_self_test");
587 nmav 1.25 if (_self_test == NULL) {
588     error = lt_dlerror();
589     if (error!=NULL) {
590     fputs(error, stderr);
591     fputs("\n", stderr);
592     }
593     return MCRYPT_UNKNOWN_ERROR;
594     }
595 nmav 1.1
596     return _self_test();
597     }
598    
599 nmav 1.5 WIN32DLL_DEFINE
600 nmav 1.1 int mcrypt_module_self_test(char *algorithm, char *a_directory)
601     {
602     int i;
603 nmav 1.17 void* rr;
604     mcrypt_dlhandle _handle;
605 nmav 1.1 int (*_self_test) (void);
606 nmav 1.8 const char* error;
607 nmav 1.1
608     if (lt_dlinit() != 0) {
609     return MCRYPT_UNKNOWN_ERROR;
610     }
611    
612 nmav 1.17 rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);
613 nmav 1.1
614 nmav 1.17 if (!rr) {
615 nmav 1.4 error=lt_dlerror();
616 nmav 1.25 if (error!=NULL) {
617     fputs( error, stderr);
618     fputs("\n", stderr);
619     }
620 nmav 1.15 lt_dlexit();
621 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
622     }
623    
624 nmav 1.17 _self_test = mcrypt_dlsym(_handle, "_mcrypt_self_test");
625 nmav 1.25 if (_self_test == NULL) {
626     mcrypt_dlclose(_handle);
627     lt_dlexit();
628     return MCRYPT_UNKNOWN_ERROR;
629     }
630    
631 nmav 1.1 i = _self_test();
632    
633 nmav 1.17 mcrypt_dlclose(_handle);
634 nmav 1.15 if (lt_dlexit() != 0) {
635     return MCRYPT_UNKNOWN_ERROR;
636     }
637    
638 nmav 1.1 return i;
639     }
640    
641 nmav 1.5 WIN32DLL_DEFINE
642 nmav 1.1 int mcrypt_module_algorithm_version(char *algorithm, char *a_directory)
643     {
644     int i;
645 nmav 1.17 mcrypt_dlhandle _handle;
646 nmav 1.1 int (*_version) (void);
647 nmav 1.8 const char* error;
648 nmav 1.17 void* rr;
649    
650 nmav 1.1 if (lt_dlinit() != 0) {
651     return MCRYPT_UNKNOWN_ERROR;
652     }
653    
654 nmav 1.17 rr = mcrypt_dlopen(&_handle, a_directory, NULL, algorithm);
655     if (!rr) {
656 nmav 1.4 error=lt_dlerror();
657 nmav 1.25 if (error!=NULL) {
658     fputs( error, stderr);
659     fputs("\n", stderr);
660     }
661     lt_dlexit();
662 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
663     }
664    
665 nmav 1.17 _version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version");
666 nmav 1.25 if (_version==NULL) {
667     mcrypt_dlclose(_handle);
668     lt_dlexit();
669     return MCRYPT_UNKNOWN_ERROR;
670     }
671 nmav 1.1
672     i = _version();
673    
674 nmav 1.17 mcrypt_dlclose(_handle);
675 nmav 1.15 if (lt_dlexit() != 0) {
676     return MCRYPT_UNKNOWN_ERROR;
677     }
678 nmav 1.1
679     return i;
680     }
681    
682 nmav 1.5 WIN32DLL_DEFINE
683 nmav 1.1 int mcrypt_module_mode_version(char *mode, char *m_directory)
684     {
685     int i;
686 nmav 1.17 mcrypt_dlhandle _handle;
687 nmav 1.1 int (*_version) (void);
688 nmav 1.8 const char* error;
689 nmav 1.17 void * rr;
690 nmav 1.1
691     if (lt_dlinit() != 0) {
692     return MCRYPT_UNKNOWN_ERROR;
693     }
694    
695 nmav 1.17 rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
696     if (!rr) {
697 nmav 1.4 error=lt_dlerror();
698 nmav 1.25 if(error!=NULL) {
699     fputs(error, stderr);
700     fputs("\n", stderr);
701     }
702 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
703     }
704    
705 nmav 1.17 _version = mcrypt_dlsym( _handle, "_mcrypt_mode_version");
706 nmav 1.25 if (_version==NULL) {
707     mcrypt_dlclose(_handle);
708     lt_dlexit();
709     return MCRYPT_UNKNOWN_ERROR;
710     }
711 nmav 1.1
712     i = _version();
713    
714 nmav 1.17 mcrypt_dlclose(_handle);
715 nmav 1.15 if (lt_dlexit() != 0) {
716     return MCRYPT_UNKNOWN_ERROR;
717     }
718 nmav 1.1
719     return i;
720     }
721    
722 nmav 1.5 WIN32DLL_DEFINE
723 nmav 1.1 int mcrypt_module_is_block_algorithm(char *algorithm, char *a_directory)
724     {
725     int i;
726 nmav 1.17 mcrypt_dlhandle _handle;
727 nmav 1.1 int (*_is_block_algorithm) (void);
728 nmav 1.8 const char* error;
729 nmav 1.17 void * rr;
730 nmav 1.4
731 nmav 1.1 if (lt_dlinit() != 0) {
732     return MCRYPT_UNKNOWN_ERROR;
733     }
734    
735 nmav 1.17 rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
736     if (!rr) {
737 nmav 1.4 error=lt_dlerror();
738 nmav 1.25 if(error!=NULL) {
739     fputs( error, stderr);
740     fputs("\n", stderr);
741     }
742 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
743     }
744    
745 nmav 1.17 _is_block_algorithm = mcrypt_dlsym(_handle, "_is_block_algorithm");
746 nmav 1.25 if (_is_block_algorithm==NULL) {
747     mcrypt_dlclose(_handle);
748     lt_dlexit();
749     return MCRYPT_UNKNOWN_ERROR;
750     }
751 nmav 1.1
752     i = _is_block_algorithm();
753    
754 nmav 1.17 mcrypt_dlclose(_handle);
755 nmav 1.15 if (lt_dlexit() != 0) {
756     return MCRYPT_UNKNOWN_ERROR;
757     }
758 nmav 1.1
759     return i;
760     }
761    
762 nmav 1.5 WIN32DLL_DEFINE
763 nmav 1.1 int mcrypt_module_is_block_algorithm_mode(char *mode, char *m_directory)
764     {
765     int i;
766 nmav 1.17 mcrypt_dlhandle _handle;
767 nmav 1.1 int (*_is_a_block_mode) (void);
768 nmav 1.8 const char* error;
769 nmav 1.17 void * rr;
770 nmav 1.1
771     if (lt_dlinit() != 0) {
772     return MCRYPT_UNKNOWN_ERROR;
773     }
774    
775 nmav 1.17 rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
776     if (!rr) {
777 nmav 1.4 error=lt_dlerror();
778 nmav 1.25 if(error!=NULL) {
779     fputs( error, stderr);
780     fputs("\n", stderr);
781     }
782 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
783     }
784    
785 nmav 1.17 _is_a_block_mode = mcrypt_dlsym(_handle, "_is_block_algorithm_mode");
786 nmav 1.25 if (_is_a_block_mode==NULL) {
787     mcrypt_dlclose(_handle);
788     lt_dlexit();
789     return MCRYPT_UNKNOWN_ERROR;
790     }
791 nmav 1.1
792     i = _is_a_block_mode();
793    
794 nmav 1.17 mcrypt_dlclose(_handle);
795 nmav 1.15 if (lt_dlexit() != 0) {
796     return MCRYPT_UNKNOWN_ERROR;
797     }
798 nmav 1.1
799     return i;
800     }
801    
802 nmav 1.5 WIN32DLL_DEFINE
803 nmav 1.1 int mcrypt_module_is_block_mode(char *mode, char *m_directory)
804     {
805 nmav 1.17 void * rr;
806 nmav 1.1 int i;
807 nmav 1.17 mcrypt_dlhandle _handle;
808 nmav 1.1 int (*_is_block_mode) (void);
809 nmav 1.8 const char* error;
810 nmav 1.1
811     if (lt_dlinit() != 0) {
812     return MCRYPT_UNKNOWN_ERROR;
813     }
814    
815 nmav 1.17 rr = mcrypt_dlopen( &_handle, m_directory, NULL, mode);
816     if (!rr) {
817 nmav 1.4 error=lt_dlerror();
818 nmav 1.25 if(error!=NULL) {
819     fputs( error, stderr);
820     fputs("\n", stderr);
821     }
822 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
823     }
824    
825 nmav 1.17 _is_block_mode = mcrypt_dlsym(_handle, "_is_block_mode");
826 nmav 1.25 if (_is_block_mode==NULL) {
827     mcrypt_dlclose(_handle);
828     lt_dlexit();
829     return MCRYPT_UNKNOWN_ERROR;
830     }
831 nmav 1.1
832     i = _is_block_mode();
833    
834 nmav 1.17 mcrypt_dlclose(_handle);
835 nmav 1.15 if (lt_dlexit() != 0) {
836     return MCRYPT_UNKNOWN_ERROR;
837     }
838 nmav 1.1
839     return i;
840     }
841    
842 nmav 1.5 WIN32DLL_DEFINE
843 nmav 1.1 int mcrypt_module_get_algo_block_size(char *algorithm, char *a_directory)
844     {
845     int i;
846 nmav 1.17 mcrypt_dlhandle _handle;
847 nmav 1.1 int (*_get_block_size) (void);
848 nmav 1.8 const char* error;
849 nmav 1.17 void * rr;
850 nmav 1.1
851     if (lt_dlinit() != 0) {
852     return MCRYPT_UNKNOWN_ERROR;
853     }
854    
855 nmav 1.17 rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
856     if (!rr) {
857 nmav 1.4 error=lt_dlerror();
858 nmav 1.25 if(error!=NULL) {
859     fputs( error, stderr);
860     fputs("\n", stderr);
861     }
862 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
863     }
864    
865 nmav 1.17 _get_block_size = mcrypt_dlsym(_handle, "_mcrypt_get_block_size");
866 nmav 1.25 if (_get_block_size==NULL) {
867     mcrypt_dlclose(_handle);
868     lt_dlexit();
869     return MCRYPT_UNKNOWN_ERROR;
870     }
871 nmav 1.1
872     i = _get_block_size();
873    
874 nmav 1.17 mcrypt_dlclose(_handle);
875 nmav 1.15 if (lt_dlexit() != 0) {
876     return MCRYPT_UNKNOWN_ERROR;
877     }
878 nmav 1.1
879     return i;
880     }
881    
882 nmav 1.5 WIN32DLL_DEFINE
883 nmav 1.1 int mcrypt_module_get_algo_key_size(char *algorithm, char *a_directory)
884     {
885     int i;
886 nmav 1.17 mcrypt_dlhandle _handle;
887 nmav 1.1 int (*_get_key_size) (void);
888 nmav 1.8 const char* error;
889 nmav 1.17 void * rr;
890 nmav 1.1
891     if (lt_dlinit() != 0) {
892     return MCRYPT_UNKNOWN_ERROR;
893     }
894    
895 nmav 1.17 rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
896     if (!rr) {
897 nmav 1.4 error=lt_dlerror();
898 nmav 1.25 if(error!=NULL) {
899     fputs( error, stderr);
900     fputs("\n", stderr);
901     }
902 nmav 1.1 return MCRYPT_UNKNOWN_ERROR;
903     }
904    
905 nmav 1.17 _get_key_size = mcrypt_dlsym(_handle, "_mcrypt_get_key_size");
906 nmav 1.25 if (_get_key_size==NULL) {
907     mcrypt_dlclose(_handle);
908     lt_dlexit();
909     return MCRYPT_UNKNOWN_ERROR;
910     }
911 nmav 1.1
912     i = _get_key_size();
913    
914 nmav 1.17 mcrypt_dlclose(_handle);
915 nmav 1.15 if (lt_dlexit() != 0) {
916     return MCRYPT_UNKNOWN_ERROR;
917     }
918 nmav 1.1
919     return i;
920     }
921    
922 nmav 1.5 WIN32DLL_DEFINE
923 nmav 1.1 int *mcrypt_module_get_algo_supported_key_sizes(char *algorithm,
924     char *a_directory,
925     int *len)
926     {
927 nmav 1.17 mcrypt_dlhandle _handle;
928 nmav 1.25 int *(*_mcrypt_get_key_sizes) (int *);
929 nmav 1.1 int *size;
930 nmav 1.21 int * ret_size;
931 nmav 1.8 const char* error;
932 nmav 1.17 void * rr;
933    
934 nmav 1.1 if (lt_dlinit() != 0) {
935     *len = 0;
936     return NULL;
937     }
938    
939 nmav 1.17 rr = mcrypt_dlopen( &_handle, a_directory, NULL, algorithm);
940     if (!rr) {
941 nmav 1.4 error=lt_dlerror();
942 nmav 1.25 if(error!=NULL) {
943     fputs( error, stderr);
944     fputs("\n", stderr);
945     }
946 nmav 1.1 *len = 0;
947     return NULL;
948     }
949    
950     _mcrypt_get_key_sizes =
951 nmav 1.17 mcrypt_dlsym(_handle, "_mcrypt_get_supported_key_sizes");
952 nmav 1.25 if (_mcrypt_get_key_sizes==NULL) {
953     mcrypt_dlclose(_handle);
954     lt_dlexit();
955     return NULL;
956     }
957 nmav 1.1
958 nmav 1.24 ret_size = NULL;
959 nmav 1.1 size = _mcrypt_get_key_sizes(len);
960 nmav 1.24 if (*len!=0 && size!=NULL) {
961 nmav 1.21 ret_size = malloc( (*len)*sizeof(int));
962     if (ret_size!=NULL) {
963     memcpy( ret_size, size, (*len)*sizeof(int));
964     }
965     }
966    
967 nmav 1.17 mcrypt_dlclose(_handle);
968 nmav 1.15 if (lt_dlexit() != 0) {
969     return NULL;
970     }
971 nmav 1.1
972 nmav 1.21 return ret_size;
973 nmav 1.1 }
webmaster@linux.gr
 ViewVC Help
Powered by ViewVC 1.1.26