/[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.29 - (hide annotations)
Sat Mar 9 21:48:51 2002 UTC (22 years ago) by nmav
Branch: MAIN
CVS Tags: libmcrypt_2_5_2, libmcrypt_2_5_0
Changes since 1.28: +21 -2 lines
File MIME type: text/plain
Added mcrypt_enc_get_state()

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

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26