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

Contents of /libmcrypt/lib/mcrypt.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.9 - (show annotations)
Tue Jan 23 11:51:19 2001 UTC (23 years, 2 months ago) by nmav
Branch: MAIN
CVS Tags: libmcrypt-2_4_9-beta
Changes since 1.8: +11 -9 lines
File MIME type: text/plain
cleanups and word8 was replaced by byte (hopefully)

1 /*
2 * Copyright (C) 1998,1999,2000 Nikos Mavroyanopoulos
3 *
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 /* $Id: mcrypt.c,v 1.8 2001/01/22 22:15:17 nmav Exp $ */
21
22 /* Changed by Steve Underwood 1999/12/10 to allow an arbitrary number of
23 * streams of encryption. Currently the resulting code is probably not
24 * thread safe, but as far as I could tell the previous code wasn't
25 * either. This version has brute force locking in a lot of places, but
26 * it has not been tested in a multi-threaded manner.
27 * The key locking issue is that the table of encryption streams could
28 * be moved when it is extended. Any address pre-calculated, or in
29 * calculation at the time of the reallocation would be screwed.
30 * This won't happen often, but requires lots of locks - PITA!
31 */
32
33 /* Changed again at 1999/12/15 to correct the thread safeness. Now it
34 * seems to be thread safe. Brute force locking was removed and
35 * locks per thread were introduced.
36 * --nikos
37 */
38
39 /* The above comments are too old! */
40
41 #ifndef LIBDEFS_H
42 #define LIBDEFS_H
43 #include <libdefs.h>
44 #endif
45 #include <bzero.h>
46 #include <xmemory.h>
47 #include <mcrypt_internal.h>
48
49 #if 0
50 static int preloaded_symbols = 0;
51 #endif
52
53 static int internal_end_mcrypt(MCRYPT td);
54
55 static int internal_init_mcrypt(MCRYPT td, void *key, int lenofkey, void *IV)
56 {
57 int *sizes = NULL;
58 int num_of_sizes, i, ok = 0;
59 int key_size = mcrypt_enc_get_key_size(td);
60
61 if (lenofkey > key_size || lenofkey==0) {
62 return MCRYPT_KEY_LEN_ERROR; /* error */
63 }
64
65 sizes = mcrypt_enc_get_supported_key_sizes(td, &num_of_sizes);
66 if (sizes != NULL) {
67 for (i = 0; i < num_of_sizes; i++) {
68 if (lenofkey == sizes[i]) {
69 ok = 1;
70 break;
71 }
72 }
73 } else { /* sizes==NULL */
74 if (num_of_sizes == 0
75 && lenofkey <= mcrypt_enc_get_key_size(td))
76 ok = 1;
77 }
78
79
80 if (ok == 0) { /* not supported key size */
81 key_size = mcrypt_enc_get_key_size(td);
82 if (sizes != NULL) {
83 for (i = 0; i < num_of_sizes; i++) {
84 if (lenofkey <= sizes[i]) {
85 key_size = sizes[i];
86 break;
87 }
88 }
89 } else { /* well every key size is supported! */
90 key_size = lenofkey;
91 }
92 } else {
93 key_size = lenofkey;
94 }
95
96 if (sizes!=NULL) free(sizes);
97
98 td->keyword_given = mxcalloc(1, mcrypt_enc_get_key_size(td));
99 if (td->keyword_given==NULL) return MCRYPT_MEMORY_ALLOCATION_ERROR;
100
101 memmove(td->keyword_given, key, lenofkey);
102 td->akey = mxcalloc(1, mcrypt_get_size(td));
103 if (td->akey==NULL) return MCRYPT_MEMORY_ALLOCATION_ERROR;
104
105 td->abuf = mxcalloc(1, mcrypt_mode_get_size(td));
106 if (td->abuf==NULL) return MCRYPT_MEMORY_ALLOCATION_ERROR;
107
108 init_mcrypt(td, td->abuf, key, key_size, IV);
109
110 ok = mcrypt_set_key(td,
111 (void *) td->akey,
112 (void *) td->keyword_given,
113 key_size, IV, mcrypt_enc_get_iv_size(td));
114
115 if (ok!=0) return MCRYPT_UNKNOWN_ERROR; /* algorithm error */
116
117 if (td->akey == NULL) {
118 internal_end_mcrypt(td);
119 return MCRYPT_UNKNOWN_ERROR;
120 }
121 return 0;
122 }
123
124 static int internal_end_mcrypt(MCRYPT td)
125 {
126 mxfree(td->keyword_given, mcrypt_enc_get_key_size(td));
127 td->keyword_given = NULL;
128
129 mxfree(td->akey, mcrypt_get_size(td));
130 td->akey = NULL;
131
132 end_mcrypt(td, td->abuf);
133 mxfree(td->abuf, mcrypt_mode_get_size(td));
134 td->abuf = NULL;
135
136 return 0;
137 }
138
139 /* Generic - High level functions */
140
141 WIN32DLL_DEFINE
142 int mcrypt_generic_init(const MCRYPT td, void *key, int lenofkey, void *IV)
143 {
144 return internal_init_mcrypt(td, key, lenofkey, IV);
145 }
146
147 WIN32DLL_DEFINE
148 int mcrypt_generic(MCRYPT td, void *plaintext, int len)
149 {
150 int x;
151
152 x = mcrypt(td, td->abuf, plaintext, len);
153 return x;
154 }
155
156 WIN32DLL_DEFINE
157 int mdecrypt_generic(MCRYPT td, void *ciphertext, int len)
158 {
159 int x;
160 x = mdecrypt(td, td->abuf, ciphertext, len);
161 return x;
162 }
163
164 WIN32DLL_DEFINE
165 int mcrypt_generic_end(const MCRYPT td)
166 {
167 internal_end_mcrypt(td);
168 mcrypt_module_close(td);
169 return 0;
170 }
171
172 WIN32DLL_DEFINE
173 void mcrypt_perror(int err)
174 {
175
176 switch (err) {
177 case MCRYPT_UNKNOWN_ERROR:
178 fprintf(stderr, "Unknown error.\n");
179 break;
180 case MCRYPT_ALGORITHM_MODE_INCOMPATIBILITY:
181 fprintf(stderr,
182 "Algorithm incompatible with this mode.\n");
183 break;
184 case MCRYPT_KEY_LEN_ERROR:
185 fprintf(stderr, "Key length is not legal.\n");
186 break;
187 case MCRYPT_MEMORY_ALLOCATION_ERROR:
188 fprintf(stderr, "Memory allocation failed.\n");
189 break;
190 case MCRYPT_UNKNOWN_MODE:
191 fprintf(stderr, "Unknown mode.\n");
192 break;
193 case MCRYPT_UNKNOWN_ALGORITHM:
194 fprintf(stderr, "Unknown algorithm.\n");
195 break;
196
197 }
198 return;
199 }
200
201 WIN32DLL_DEFINE
202 char* mcrypt_strerror(int err)
203 {
204 char* cerr=malloc(256);
205 if (cerr==NULL) return NULL;
206
207 switch (err) {
208 case MCRYPT_UNKNOWN_ERROR:
209 sprintf(cerr, "Unknown error.\n");
210 break;
211 case MCRYPT_ALGORITHM_MODE_INCOMPATIBILITY:
212 sprintf(cerr,
213 "Algorithm incompatible with this mode.\n");
214 break;
215 case MCRYPT_KEY_LEN_ERROR:
216 sprintf(cerr, "Key length is not legal.\n");
217 break;
218 case MCRYPT_MEMORY_ALLOCATION_ERROR:
219 sprintf(cerr, "Memory allocation failed.\n");
220 break;
221 case MCRYPT_UNKNOWN_MODE:
222 sprintf(cerr, "Unknown mode.\n");
223 break;
224 case MCRYPT_UNKNOWN_ALGORITHM:
225 sprintf(cerr, "Unknown algorithm.\n");
226 break;
227
228 }
229 return cerr;
230 }
231
232 WIN32DLL_DEFINE
233 int mcrypt_free(void *ptr)
234 {
235 free(ptr);
236 return 0;
237 }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26