diff options
author | cvs2svn <admin@example.com> | 2002-05-15 02:29:23 +0000 |
---|---|---|
committer | cvs2svn <admin@example.com> | 2002-05-15 02:29:23 +0000 |
commit | fd9566423b542798f5c8b06e68101a9ea5bb9885 (patch) | |
tree | f2cc037857a260afc5aaaaaa6cf62d06923c6273 /src/lib/libcrypto/evp | |
parent | 536c76cbb863bab152f19842ab88772c01e922c7 (diff) | |
download | openbsd-fd9566423b542798f5c8b06e68101a9ea5bb9885.tar.gz openbsd-fd9566423b542798f5c8b06e68101a9ea5bb9885.tar.bz2 openbsd-fd9566423b542798f5c8b06e68101a9ea5bb9885.zip |
This commit was manufactured by cvs2git to create branch 'openssl'.
Diffstat (limited to 'src/lib/libcrypto/evp')
-rw-r--r-- | src/lib/libcrypto/evp/bio_ok.c | 552 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/c_allc.c | 149 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/c_alld.c | 100 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/e_rc5.c | 118 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/evp_acnf.c | 74 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/evp_test.c | 365 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/evptests.txt | 82 | ||||
-rw-r--r-- | src/lib/libcrypto/evp/openbsd_hw.c | 446 |
8 files changed, 1886 insertions, 0 deletions
diff --git a/src/lib/libcrypto/evp/bio_ok.c b/src/lib/libcrypto/evp/bio_ok.c new file mode 100644 index 0000000000..101275d648 --- /dev/null +++ b/src/lib/libcrypto/evp/bio_ok.c | |||
@@ -0,0 +1,552 @@ | |||
1 | /* crypto/evp/bio_ok.c */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | /* | ||
60 | From: Arne Ansper <arne@cyber.ee> | ||
61 | |||
62 | Why BIO_f_reliable? | ||
63 | |||
64 | I wrote function which took BIO* as argument, read data from it | ||
65 | and processed it. Then I wanted to store the input file in | ||
66 | encrypted form. OK I pushed BIO_f_cipher to the BIO stack | ||
67 | and everything was OK. BUT if user types wrong password | ||
68 | BIO_f_cipher outputs only garbage and my function crashes. Yes | ||
69 | I can and I should fix my function, but BIO_f_cipher is | ||
70 | easy way to add encryption support to many exisiting applications | ||
71 | and it's hard to debug and fix them all. | ||
72 | |||
73 | So I wanted another BIO which would catch the incorrect passwords and | ||
74 | file damages which cause garbage on BIO_f_cipher's output. | ||
75 | |||
76 | The easy way is to push the BIO_f_md and save the checksum at | ||
77 | the end of the file. However there are several problems with this | ||
78 | approach: | ||
79 | |||
80 | 1) you must somehow separate checksum from actual data. | ||
81 | 2) you need lot's of memory when reading the file, because you | ||
82 | must read to the end of the file and verify the checksum before | ||
83 | leting the application to read the data. | ||
84 | |||
85 | BIO_f_reliable tries to solve both problems, so that you can | ||
86 | read and write arbitraly long streams using only fixed amount | ||
87 | of memory. | ||
88 | |||
89 | BIO_f_reliable splits data stream into blocks. Each block is prefixed | ||
90 | with it's length and suffixed with it's digest. So you need only | ||
91 | several Kbytes of memory to buffer single block before verifying | ||
92 | it's digest. | ||
93 | |||
94 | BIO_f_reliable goes futher and adds several important capabilities: | ||
95 | |||
96 | 1) the digest of the block is computed over the whole stream | ||
97 | -- so nobody can rearrange the blocks or remove or replace them. | ||
98 | |||
99 | 2) to detect invalid passwords right at the start BIO_f_reliable | ||
100 | adds special prefix to the stream. In order to avoid known plain-text | ||
101 | attacks this prefix is generated as follows: | ||
102 | |||
103 | *) digest is initialized with random seed instead of | ||
104 | standardized one. | ||
105 | *) same seed is written to ouput | ||
106 | *) well-known text is then hashed and the output | ||
107 | of the digest is also written to output. | ||
108 | |||
109 | reader can now read the seed from stream, hash the same string | ||
110 | and then compare the digest output. | ||
111 | |||
112 | Bad things: BIO_f_reliable knows what's going on in EVP_Digest. I | ||
113 | initialy wrote and tested this code on x86 machine and wrote the | ||
114 | digests out in machine-dependent order :( There are people using | ||
115 | this code and I cannot change this easily without making existing | ||
116 | data files unreadable. | ||
117 | |||
118 | */ | ||
119 | |||
120 | #include <stdio.h> | ||
121 | #include <errno.h> | ||
122 | #include "cryptlib.h" | ||
123 | #include <openssl/buffer.h> | ||
124 | #include <openssl/bio.h> | ||
125 | #include <openssl/evp.h> | ||
126 | #include <openssl/rand.h> | ||
127 | |||
128 | static int ok_write(BIO *h,char *buf,int num); | ||
129 | static int ok_read(BIO *h,char *buf,int size); | ||
130 | static long ok_ctrl(BIO *h,int cmd,long arg1,char *arg2); | ||
131 | static int ok_new(BIO *h); | ||
132 | static int ok_free(BIO *data); | ||
133 | static void sig_out(BIO* b); | ||
134 | static void sig_in(BIO* b); | ||
135 | static void block_out(BIO* b); | ||
136 | static void block_in(BIO* b); | ||
137 | #define OK_BLOCK_SIZE (1024*4) | ||
138 | #define OK_BLOCK_BLOCK 4 | ||
139 | #define IOBS (OK_BLOCK_SIZE+ OK_BLOCK_BLOCK+ 3*EVP_MAX_MD_SIZE) | ||
140 | #define WELLKNOWN "The quick brown fox jumped over the lazy dog's back." | ||
141 | |||
142 | #ifndef L_ENDIAN | ||
143 | #define swapem(x) \ | ||
144 | ((unsigned long int)((((unsigned long int)(x) & 0x000000ffU) << 24) | \ | ||
145 | (((unsigned long int)(x) & 0x0000ff00U) << 8) | \ | ||
146 | (((unsigned long int)(x) & 0x00ff0000U) >> 8) | \ | ||
147 | (((unsigned long int)(x) & 0xff000000U) >> 24))) | ||
148 | #else | ||
149 | #define swapem(x) (x) | ||
150 | #endif | ||
151 | |||
152 | typedef struct ok_struct | ||
153 | { | ||
154 | int buf_len; | ||
155 | int buf_off; | ||
156 | int buf_len_save; | ||
157 | int buf_off_save; | ||
158 | int cont; /* <= 0 when finished */ | ||
159 | int finished; | ||
160 | EVP_MD_CTX md; | ||
161 | int blockout; /* output block is ready */ | ||
162 | int sigio; /* must process signature */ | ||
163 | char buf[IOBS]; | ||
164 | } BIO_OK_CTX; | ||
165 | |||
166 | static BIO_METHOD methods_ok= | ||
167 | { | ||
168 | BIO_TYPE_CIPHER,"reliable", | ||
169 | ok_write, | ||
170 | ok_read, | ||
171 | NULL, /* ok_puts, */ | ||
172 | NULL, /* ok_gets, */ | ||
173 | ok_ctrl, | ||
174 | ok_new, | ||
175 | ok_free, | ||
176 | }; | ||
177 | |||
178 | BIO_METHOD *BIO_f_reliable(void) | ||
179 | { | ||
180 | return(&methods_ok); | ||
181 | } | ||
182 | |||
183 | static int ok_new(BIO *bi) | ||
184 | { | ||
185 | BIO_OK_CTX *ctx; | ||
186 | |||
187 | ctx=(BIO_OK_CTX *)Malloc(sizeof(BIO_OK_CTX)); | ||
188 | if (ctx == NULL) return(0); | ||
189 | |||
190 | ctx->buf_len=0; | ||
191 | ctx->buf_off=0; | ||
192 | ctx->buf_len_save=0; | ||
193 | ctx->buf_off_save=0; | ||
194 | ctx->cont=1; | ||
195 | ctx->finished=0; | ||
196 | ctx->blockout= 0; | ||
197 | ctx->sigio=1; | ||
198 | |||
199 | bi->init=0; | ||
200 | bi->ptr=(char *)ctx; | ||
201 | bi->flags=0; | ||
202 | return(1); | ||
203 | } | ||
204 | |||
205 | static int ok_free(BIO *a) | ||
206 | { | ||
207 | if (a == NULL) return(0); | ||
208 | memset(a->ptr,0,sizeof(BIO_OK_CTX)); | ||
209 | Free(a->ptr); | ||
210 | a->ptr=NULL; | ||
211 | a->init=0; | ||
212 | a->flags=0; | ||
213 | return(1); | ||
214 | } | ||
215 | |||
216 | static int ok_read(BIO *b, char *out, int outl) | ||
217 | { | ||
218 | int ret=0,i,n; | ||
219 | BIO_OK_CTX *ctx; | ||
220 | |||
221 | if (out == NULL) return(0); | ||
222 | ctx=(BIO_OK_CTX *)b->ptr; | ||
223 | |||
224 | if ((ctx == NULL) || (b->next_bio == NULL) || (b->init == 0)) return(0); | ||
225 | |||
226 | while(outl > 0) | ||
227 | { | ||
228 | |||
229 | /* copy clean bytes to output buffer */ | ||
230 | if (ctx->blockout) | ||
231 | { | ||
232 | i=ctx->buf_len-ctx->buf_off; | ||
233 | if (i > outl) i=outl; | ||
234 | memcpy(out,&(ctx->buf[ctx->buf_off]),i); | ||
235 | ret+=i; | ||
236 | out+=i; | ||
237 | outl-=i; | ||
238 | ctx->buf_off+=i; | ||
239 | |||
240 | /* all clean bytes are out */ | ||
241 | if (ctx->buf_len == ctx->buf_off) | ||
242 | { | ||
243 | ctx->buf_off=0; | ||
244 | |||
245 | /* copy start of the next block into proper place */ | ||
246 | if(ctx->buf_len_save- ctx->buf_off_save > 0) | ||
247 | { | ||
248 | ctx->buf_len= ctx->buf_len_save- ctx->buf_off_save; | ||
249 | memmove(ctx->buf, &(ctx->buf[ctx->buf_off_save]), | ||
250 | ctx->buf_len); | ||
251 | } | ||
252 | else | ||
253 | { | ||
254 | ctx->buf_len=0; | ||
255 | } | ||
256 | ctx->blockout= 0; | ||
257 | } | ||
258 | } | ||
259 | |||
260 | /* output buffer full -- cancel */ | ||
261 | if (outl == 0) break; | ||
262 | |||
263 | /* no clean bytes in buffer -- fill it */ | ||
264 | n=IOBS- ctx->buf_len; | ||
265 | i=BIO_read(b->next_bio,&(ctx->buf[ctx->buf_len]),n); | ||
266 | |||
267 | if (i <= 0) break; /* nothing new */ | ||
268 | |||
269 | ctx->buf_len+= i; | ||
270 | |||
271 | /* no signature yet -- check if we got one */ | ||
272 | if (ctx->sigio == 1) sig_in(b); | ||
273 | |||
274 | /* signature ok -- check if we got block */ | ||
275 | if (ctx->sigio == 0) block_in(b); | ||
276 | |||
277 | /* invalid block -- cancel */ | ||
278 | if (ctx->cont <= 0) break; | ||
279 | |||
280 | } | ||
281 | |||
282 | BIO_clear_retry_flags(b); | ||
283 | BIO_copy_next_retry(b); | ||
284 | return(ret); | ||
285 | } | ||
286 | |||
287 | static int ok_write(BIO *b, char *in, int inl) | ||
288 | { | ||
289 | int ret=0,n,i; | ||
290 | BIO_OK_CTX *ctx; | ||
291 | |||
292 | ctx=(BIO_OK_CTX *)b->ptr; | ||
293 | ret=inl; | ||
294 | |||
295 | if ((ctx == NULL) || (b->next_bio == NULL) || (b->init == 0)) return(0); | ||
296 | |||
297 | if(ctx->sigio) sig_out(b); | ||
298 | |||
299 | do{ | ||
300 | BIO_clear_retry_flags(b); | ||
301 | n=ctx->buf_len-ctx->buf_off; | ||
302 | while (ctx->blockout && n > 0) | ||
303 | { | ||
304 | i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n); | ||
305 | if (i <= 0) | ||
306 | { | ||
307 | BIO_copy_next_retry(b); | ||
308 | if(!BIO_should_retry(b)) | ||
309 | ctx->cont= 0; | ||
310 | return(i); | ||
311 | } | ||
312 | ctx->buf_off+=i; | ||
313 | n-=i; | ||
314 | } | ||
315 | |||
316 | /* at this point all pending data has been written */ | ||
317 | ctx->blockout= 0; | ||
318 | if (ctx->buf_len == ctx->buf_off) | ||
319 | { | ||
320 | ctx->buf_len=OK_BLOCK_BLOCK; | ||
321 | ctx->buf_off=0; | ||
322 | } | ||
323 | |||
324 | if ((in == NULL) || (inl <= 0)) return(0); | ||
325 | |||
326 | n= (inl+ ctx->buf_len > OK_BLOCK_SIZE+ OK_BLOCK_BLOCK) ? | ||
327 | OK_BLOCK_SIZE+ OK_BLOCK_BLOCK- ctx->buf_len : inl; | ||
328 | |||
329 | memcpy((unsigned char *)(&(ctx->buf[ctx->buf_len])),(unsigned char *)in,n); | ||
330 | ctx->buf_len+= n; | ||
331 | inl-=n; | ||
332 | in+=n; | ||
333 | |||
334 | if(ctx->buf_len >= OK_BLOCK_SIZE+ OK_BLOCK_BLOCK) | ||
335 | { | ||
336 | block_out(b); | ||
337 | } | ||
338 | }while(inl > 0); | ||
339 | |||
340 | BIO_clear_retry_flags(b); | ||
341 | BIO_copy_next_retry(b); | ||
342 | return(ret); | ||
343 | } | ||
344 | |||
345 | static long ok_ctrl(BIO *b, int cmd, long num, char *ptr) | ||
346 | { | ||
347 | BIO_OK_CTX *ctx; | ||
348 | EVP_MD *md; | ||
349 | const EVP_MD **ppmd; | ||
350 | long ret=1; | ||
351 | int i; | ||
352 | |||
353 | ctx=(BIO_OK_CTX *)b->ptr; | ||
354 | |||
355 | switch (cmd) | ||
356 | { | ||
357 | case BIO_CTRL_RESET: | ||
358 | ctx->buf_len=0; | ||
359 | ctx->buf_off=0; | ||
360 | ctx->buf_len_save=0; | ||
361 | ctx->buf_off_save=0; | ||
362 | ctx->cont=1; | ||
363 | ctx->finished=0; | ||
364 | ctx->blockout= 0; | ||
365 | ctx->sigio=1; | ||
366 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
367 | break; | ||
368 | case BIO_CTRL_EOF: /* More to read */ | ||
369 | if (ctx->cont <= 0) | ||
370 | ret=1; | ||
371 | else | ||
372 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
373 | break; | ||
374 | case BIO_CTRL_PENDING: /* More to read in buffer */ | ||
375 | case BIO_CTRL_WPENDING: /* More to read in buffer */ | ||
376 | ret=ctx->blockout ? ctx->buf_len-ctx->buf_off : 0; | ||
377 | if (ret <= 0) | ||
378 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
379 | break; | ||
380 | case BIO_CTRL_FLUSH: | ||
381 | /* do a final write */ | ||
382 | if(ctx->blockout == 0) | ||
383 | block_out(b); | ||
384 | |||
385 | while (ctx->blockout) | ||
386 | { | ||
387 | i=ok_write(b,NULL,0); | ||
388 | if (i < 0) | ||
389 | { | ||
390 | ret=i; | ||
391 | break; | ||
392 | } | ||
393 | } | ||
394 | |||
395 | ctx->finished=1; | ||
396 | ctx->buf_off=ctx->buf_len=0; | ||
397 | ctx->cont=(int)ret; | ||
398 | |||
399 | /* Finally flush the underlying BIO */ | ||
400 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
401 | break; | ||
402 | case BIO_C_DO_STATE_MACHINE: | ||
403 | BIO_clear_retry_flags(b); | ||
404 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
405 | BIO_copy_next_retry(b); | ||
406 | break; | ||
407 | case BIO_CTRL_INFO: | ||
408 | ret=(long)ctx->cont; | ||
409 | break; | ||
410 | case BIO_C_SET_MD: | ||
411 | md=(EVP_MD *)ptr; | ||
412 | EVP_DigestInit(&(ctx->md),md); | ||
413 | b->init=1; | ||
414 | break; | ||
415 | case BIO_C_GET_MD: | ||
416 | if (b->init) | ||
417 | { | ||
418 | ppmd=(const EVP_MD **)ptr; | ||
419 | *ppmd=ctx->md.digest; | ||
420 | } | ||
421 | else | ||
422 | ret=0; | ||
423 | break; | ||
424 | default: | ||
425 | ret=BIO_ctrl(b->next_bio,cmd,num,ptr); | ||
426 | break; | ||
427 | } | ||
428 | return(ret); | ||
429 | } | ||
430 | |||
431 | static void longswap(void *_ptr, int len) | ||
432 | { | ||
433 | #ifndef L_ENDIAN | ||
434 | int i; | ||
435 | char *ptr=_ptr; | ||
436 | |||
437 | for(i= 0;i < len;i+= 4){ | ||
438 | *((unsigned long *)&(ptr[i]))= swapem(*((unsigned long *)&(ptr[i]))); | ||
439 | } | ||
440 | #endif | ||
441 | } | ||
442 | |||
443 | static void sig_out(BIO* b) | ||
444 | { | ||
445 | BIO_OK_CTX *ctx; | ||
446 | EVP_MD_CTX *md; | ||
447 | |||
448 | ctx=(BIO_OK_CTX *)b->ptr; | ||
449 | md= &(ctx->md); | ||
450 | |||
451 | if(ctx->buf_len+ 2* md->digest->md_size > OK_BLOCK_SIZE) return; | ||
452 | |||
453 | EVP_DigestInit(md, md->digest); | ||
454 | RAND_bytes(&(md->md.base[0]), md->digest->md_size); | ||
455 | memcpy(&(ctx->buf[ctx->buf_len]), &(md->md.base[0]), md->digest->md_size); | ||
456 | longswap(&(ctx->buf[ctx->buf_len]), md->digest->md_size); | ||
457 | ctx->buf_len+= md->digest->md_size; | ||
458 | |||
459 | EVP_DigestUpdate(md, (unsigned char*)WELLKNOWN, strlen(WELLKNOWN)); | ||
460 | md->digest->final(&(ctx->buf[ctx->buf_len]), &(md->md.base[0])); | ||
461 | ctx->buf_len+= md->digest->md_size; | ||
462 | ctx->blockout= 1; | ||
463 | ctx->sigio= 0; | ||
464 | } | ||
465 | |||
466 | static void sig_in(BIO* b) | ||
467 | { | ||
468 | BIO_OK_CTX *ctx; | ||
469 | EVP_MD_CTX *md; | ||
470 | unsigned char tmp[EVP_MAX_MD_SIZE]; | ||
471 | int ret= 0; | ||
472 | |||
473 | ctx=(BIO_OK_CTX *)b->ptr; | ||
474 | md= &(ctx->md); | ||
475 | |||
476 | if(ctx->buf_len- ctx->buf_off < 2* md->digest->md_size) return; | ||
477 | |||
478 | EVP_DigestInit(md, md->digest); | ||
479 | memcpy(&(md->md.base[0]), &(ctx->buf[ctx->buf_off]), md->digest->md_size); | ||
480 | longswap(&(md->md.base[0]), md->digest->md_size); | ||
481 | ctx->buf_off+= md->digest->md_size; | ||
482 | |||
483 | EVP_DigestUpdate(md, (unsigned char*)WELLKNOWN, strlen(WELLKNOWN)); | ||
484 | md->digest->final(tmp, &(md->md.base[0])); | ||
485 | ret= memcmp(&(ctx->buf[ctx->buf_off]), tmp, md->digest->md_size) == 0; | ||
486 | ctx->buf_off+= md->digest->md_size; | ||
487 | if(ret == 1) | ||
488 | { | ||
489 | ctx->sigio= 0; | ||
490 | if(ctx->buf_len != ctx->buf_off) | ||
491 | { | ||
492 | memmove(ctx->buf, &(ctx->buf[ctx->buf_off]), ctx->buf_len- ctx->buf_off); | ||
493 | } | ||
494 | ctx->buf_len-= ctx->buf_off; | ||
495 | ctx->buf_off= 0; | ||
496 | } | ||
497 | else | ||
498 | { | ||
499 | ctx->cont= 0; | ||
500 | } | ||
501 | } | ||
502 | |||
503 | static void block_out(BIO* b) | ||
504 | { | ||
505 | BIO_OK_CTX *ctx; | ||
506 | EVP_MD_CTX *md; | ||
507 | unsigned long tl; | ||
508 | |||
509 | ctx=(BIO_OK_CTX *)b->ptr; | ||
510 | md= &(ctx->md); | ||
511 | |||
512 | tl= ctx->buf_len- OK_BLOCK_BLOCK; | ||
513 | tl= swapem(tl); | ||
514 | memcpy(ctx->buf, &tl, OK_BLOCK_BLOCK); | ||
515 | tl= swapem(tl); | ||
516 | EVP_DigestUpdate(md, (unsigned char*) &(ctx->buf[OK_BLOCK_BLOCK]), tl); | ||
517 | md->digest->final(&(ctx->buf[ctx->buf_len]), &(md->md.base[0])); | ||
518 | ctx->buf_len+= md->digest->md_size; | ||
519 | ctx->blockout= 1; | ||
520 | } | ||
521 | |||
522 | static void block_in(BIO* b) | ||
523 | { | ||
524 | BIO_OK_CTX *ctx; | ||
525 | EVP_MD_CTX *md; | ||
526 | long tl= 0; | ||
527 | unsigned char tmp[EVP_MAX_MD_SIZE]; | ||
528 | |||
529 | ctx=(BIO_OK_CTX *)b->ptr; | ||
530 | md= &(ctx->md); | ||
531 | |||
532 | memcpy(&tl, ctx->buf, OK_BLOCK_BLOCK); | ||
533 | tl= swapem(tl); | ||
534 | if (ctx->buf_len < tl+ OK_BLOCK_BLOCK+ md->digest->md_size) return; | ||
535 | |||
536 | EVP_DigestUpdate(md, (unsigned char*) &(ctx->buf[OK_BLOCK_BLOCK]), tl); | ||
537 | md->digest->final(tmp, &(md->md.base[0])); | ||
538 | if(memcmp(&(ctx->buf[tl+ OK_BLOCK_BLOCK]), tmp, md->digest->md_size) == 0) | ||
539 | { | ||
540 | /* there might be parts from next block lurking around ! */ | ||
541 | ctx->buf_off_save= tl+ OK_BLOCK_BLOCK+ md->digest->md_size; | ||
542 | ctx->buf_len_save= ctx->buf_len; | ||
543 | ctx->buf_off= OK_BLOCK_BLOCK; | ||
544 | ctx->buf_len= tl+ OK_BLOCK_BLOCK; | ||
545 | ctx->blockout= 1; | ||
546 | } | ||
547 | else | ||
548 | { | ||
549 | ctx->cont= 0; | ||
550 | } | ||
551 | } | ||
552 | |||
diff --git a/src/lib/libcrypto/evp/c_allc.c b/src/lib/libcrypto/evp/c_allc.c new file mode 100644 index 0000000000..f24d3756c9 --- /dev/null +++ b/src/lib/libcrypto/evp/c_allc.c | |||
@@ -0,0 +1,149 @@ | |||
1 | /* crypto/evp/c_allc.c */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include "cryptlib.h" | ||
61 | #include <openssl/evp.h> | ||
62 | #include <openssl/pkcs12.h> | ||
63 | #include <openssl/objects.h> | ||
64 | |||
65 | void OpenSSL_add_all_ciphers(void) | ||
66 | { | ||
67 | #ifndef NO_DES | ||
68 | EVP_add_cipher(EVP_des_cfb()); | ||
69 | EVP_add_cipher(EVP_des_ede_cfb()); | ||
70 | EVP_add_cipher(EVP_des_ede3_cfb()); | ||
71 | |||
72 | EVP_add_cipher(EVP_des_ofb()); | ||
73 | EVP_add_cipher(EVP_des_ede_ofb()); | ||
74 | EVP_add_cipher(EVP_des_ede3_ofb()); | ||
75 | |||
76 | EVP_add_cipher(EVP_desx_cbc()); | ||
77 | EVP_add_cipher_alias(SN_desx_cbc,"DESX"); | ||
78 | EVP_add_cipher_alias(SN_desx_cbc,"desx"); | ||
79 | |||
80 | EVP_add_cipher(EVP_des_cbc()); | ||
81 | EVP_add_cipher_alias(SN_des_cbc,"DES"); | ||
82 | EVP_add_cipher_alias(SN_des_cbc,"des"); | ||
83 | EVP_add_cipher(EVP_des_ede_cbc()); | ||
84 | EVP_add_cipher(EVP_des_ede3_cbc()); | ||
85 | EVP_add_cipher_alias(SN_des_ede3_cbc,"DES3"); | ||
86 | EVP_add_cipher_alias(SN_des_ede3_cbc,"des3"); | ||
87 | |||
88 | EVP_add_cipher(EVP_des_ecb()); | ||
89 | EVP_add_cipher(EVP_des_ede()); | ||
90 | EVP_add_cipher(EVP_des_ede3()); | ||
91 | #endif | ||
92 | |||
93 | #ifndef NO_RC4 | ||
94 | EVP_add_cipher(EVP_rc4()); | ||
95 | EVP_add_cipher(EVP_rc4_40()); | ||
96 | #endif | ||
97 | |||
98 | #ifndef NO_IDEA | ||
99 | EVP_add_cipher(EVP_idea_ecb()); | ||
100 | EVP_add_cipher(EVP_idea_cfb()); | ||
101 | EVP_add_cipher(EVP_idea_ofb()); | ||
102 | EVP_add_cipher(EVP_idea_cbc()); | ||
103 | EVP_add_cipher_alias(SN_idea_cbc,"IDEA"); | ||
104 | EVP_add_cipher_alias(SN_idea_cbc,"idea"); | ||
105 | #endif | ||
106 | |||
107 | #ifndef NO_RC2 | ||
108 | EVP_add_cipher(EVP_rc2_ecb()); | ||
109 | EVP_add_cipher(EVP_rc2_cfb()); | ||
110 | EVP_add_cipher(EVP_rc2_ofb()); | ||
111 | EVP_add_cipher(EVP_rc2_cbc()); | ||
112 | EVP_add_cipher(EVP_rc2_40_cbc()); | ||
113 | EVP_add_cipher(EVP_rc2_64_cbc()); | ||
114 | EVP_add_cipher_alias(SN_rc2_cbc,"RC2"); | ||
115 | EVP_add_cipher_alias(SN_rc2_cbc,"rc2"); | ||
116 | #endif | ||
117 | |||
118 | #ifndef NO_BF | ||
119 | EVP_add_cipher(EVP_bf_ecb()); | ||
120 | EVP_add_cipher(EVP_bf_cfb()); | ||
121 | EVP_add_cipher(EVP_bf_ofb()); | ||
122 | EVP_add_cipher(EVP_bf_cbc()); | ||
123 | EVP_add_cipher_alias(SN_bf_cbc,"BF"); | ||
124 | EVP_add_cipher_alias(SN_bf_cbc,"bf"); | ||
125 | EVP_add_cipher_alias(SN_bf_cbc,"blowfish"); | ||
126 | #endif | ||
127 | |||
128 | #ifndef NO_CAST | ||
129 | EVP_add_cipher(EVP_cast5_ecb()); | ||
130 | EVP_add_cipher(EVP_cast5_cfb()); | ||
131 | EVP_add_cipher(EVP_cast5_ofb()); | ||
132 | EVP_add_cipher(EVP_cast5_cbc()); | ||
133 | EVP_add_cipher_alias(SN_cast5_cbc,"CAST"); | ||
134 | EVP_add_cipher_alias(SN_cast5_cbc,"cast"); | ||
135 | EVP_add_cipher_alias(SN_cast5_cbc,"CAST-cbc"); | ||
136 | EVP_add_cipher_alias(SN_cast5_cbc,"cast-cbc"); | ||
137 | #endif | ||
138 | |||
139 | #ifndef NO_RC5 | ||
140 | EVP_add_cipher(EVP_rc5_32_12_16_ecb()); | ||
141 | EVP_add_cipher(EVP_rc5_32_12_16_cfb()); | ||
142 | EVP_add_cipher(EVP_rc5_32_12_16_ofb()); | ||
143 | EVP_add_cipher(EVP_rc5_32_12_16_cbc()); | ||
144 | EVP_add_cipher_alias(SN_rc5_cbc,"rc5"); | ||
145 | EVP_add_cipher_alias(SN_rc5_cbc,"RC5"); | ||
146 | #endif | ||
147 | PKCS12_PBE_add(); | ||
148 | PKCS5_PBE_add(); | ||
149 | } | ||
diff --git a/src/lib/libcrypto/evp/c_alld.c b/src/lib/libcrypto/evp/c_alld.c new file mode 100644 index 0000000000..febe51a3ee --- /dev/null +++ b/src/lib/libcrypto/evp/c_alld.c | |||
@@ -0,0 +1,100 @@ | |||
1 | /* crypto/evp/c_alld.c */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | #include <stdio.h> | ||
60 | #include "cryptlib.h" | ||
61 | #include <openssl/evp.h> | ||
62 | #include <openssl/pkcs12.h> | ||
63 | #include <openssl/objects.h> | ||
64 | |||
65 | void OpenSSL_add_all_digests(void) | ||
66 | { | ||
67 | #ifndef NO_MD2 | ||
68 | EVP_add_digest(EVP_md2()); | ||
69 | #endif | ||
70 | #ifndef NO_MD5 | ||
71 | EVP_add_digest(EVP_md5()); | ||
72 | EVP_add_digest_alias(SN_md5,"ssl2-md5"); | ||
73 | EVP_add_digest_alias(SN_md5,"ssl3-md5"); | ||
74 | #endif | ||
75 | #ifndef NO_SHA | ||
76 | EVP_add_digest(EVP_sha()); | ||
77 | #ifndef NO_DSA | ||
78 | EVP_add_digest(EVP_dss()); | ||
79 | #endif | ||
80 | #endif | ||
81 | #ifndef NO_SHA | ||
82 | EVP_add_digest(EVP_sha1()); | ||
83 | EVP_add_digest_alias(SN_sha1,"ssl3-sha1"); | ||
84 | EVP_add_digest_alias(SN_sha1WithRSAEncryption,SN_sha1WithRSA); | ||
85 | #ifndef NO_DSA | ||
86 | EVP_add_digest(EVP_dss1()); | ||
87 | EVP_add_digest_alias(SN_dsaWithSHA1,SN_dsaWithSHA1_2); | ||
88 | EVP_add_digest_alias(SN_dsaWithSHA1,"DSS1"); | ||
89 | EVP_add_digest_alias(SN_dsaWithSHA1,"dss1"); | ||
90 | #endif | ||
91 | #endif | ||
92 | #if !defined(NO_MDC2) && !defined(NO_DES) | ||
93 | EVP_add_digest(EVP_mdc2()); | ||
94 | #endif | ||
95 | #ifndef NO_RIPEMD | ||
96 | EVP_add_digest(EVP_ripemd160()); | ||
97 | EVP_add_digest_alias(SN_ripemd160,"ripemd"); | ||
98 | EVP_add_digest_alias(SN_ripemd160,"rmd160"); | ||
99 | #endif | ||
100 | } | ||
diff --git a/src/lib/libcrypto/evp/e_rc5.c b/src/lib/libcrypto/evp/e_rc5.c new file mode 100644 index 0000000000..5885f1826b --- /dev/null +++ b/src/lib/libcrypto/evp/e_rc5.c | |||
@@ -0,0 +1,118 @@ | |||
1 | /* crypto/evp/e_rc5.c */ | ||
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This package is an SSL implementation written | ||
6 | * by Eric Young (eay@cryptsoft.com). | ||
7 | * The implementation was written so as to conform with Netscapes SSL. | ||
8 | * | ||
9 | * This library is free for commercial and non-commercial use as long as | ||
10 | * the following conditions are aheared to. The following conditions | ||
11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
13 | * included with this distribution is covered by the same copyright terms | ||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
15 | * | ||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
17 | * the code are not to be removed. | ||
18 | * If this package is used in a product, Eric Young should be given attribution | ||
19 | * as the author of the parts of the library used. | ||
20 | * This can be in the form of a textual message at program startup or | ||
21 | * in documentation (online or textual) provided with the package. | ||
22 | * | ||
23 | * Redistribution and use in source and binary forms, with or without | ||
24 | * modification, are permitted provided that the following conditions | ||
25 | * are met: | ||
26 | * 1. Redistributions of source code must retain the copyright | ||
27 | * notice, this list of conditions and the following disclaimer. | ||
28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
29 | * notice, this list of conditions and the following disclaimer in the | ||
30 | * documentation and/or other materials provided with the distribution. | ||
31 | * 3. All advertising materials mentioning features or use of this software | ||
32 | * must display the following acknowledgement: | ||
33 | * "This product includes cryptographic software written by | ||
34 | * Eric Young (eay@cryptsoft.com)" | ||
35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
36 | * being used are not cryptographic related :-). | ||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
38 | * the apps directory (application code) you must include an acknowledgement: | ||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
40 | * | ||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
51 | * SUCH DAMAGE. | ||
52 | * | ||
53 | * The licence and distribution terms for any publically available version or | ||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
55 | * copied and put under another distribution licence | ||
56 | * [including the GNU Public Licence.] | ||
57 | */ | ||
58 | |||
59 | #ifndef NO_RC5 | ||
60 | |||
61 | #include <stdio.h> | ||
62 | #include "cryptlib.h" | ||
63 | #include <openssl/evp.h> | ||
64 | #include <openssl/objects.h> | ||
65 | #include "evp_locl.h" | ||
66 | |||
67 | static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | ||
68 | const unsigned char *iv,int enc); | ||
69 | static int rc5_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr); | ||
70 | |||
71 | IMPLEMENT_BLOCK_CIPHER(rc5_32_12_16, rc5.ks, RC5_32, rc5, NID_rc5, | ||
72 | 8, EVP_RC5_32_12_16_KEY_SIZE, 8, | ||
73 | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT, | ||
74 | r_32_12_16_init_key, NULL, | ||
75 | NULL, NULL, rc5_ctrl) | ||
76 | |||
77 | |||
78 | |||
79 | static int rc5_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) | ||
80 | { | ||
81 | switch(type) { | ||
82 | |||
83 | case EVP_CTRL_INIT: | ||
84 | c->c.rc5.rounds = RC5_12_ROUNDS; | ||
85 | return 1; | ||
86 | |||
87 | case EVP_CTRL_GET_RC5_ROUNDS: | ||
88 | *(int *)ptr = c->c.rc5.rounds; | ||
89 | return 1; | ||
90 | |||
91 | |||
92 | case EVP_CTRL_SET_RC5_ROUNDS: | ||
93 | switch(arg) { | ||
94 | case RC5_8_ROUNDS: | ||
95 | case RC5_12_ROUNDS: | ||
96 | case RC5_16_ROUNDS: | ||
97 | c->c.rc5.rounds = arg; | ||
98 | return 1; | ||
99 | |||
100 | default: | ||
101 | EVPerr(EVP_F_RC5_CTRL, EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS); | ||
102 | return 0; | ||
103 | } | ||
104 | |||
105 | default: | ||
106 | return -1; | ||
107 | } | ||
108 | } | ||
109 | |||
110 | static int r_32_12_16_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | ||
111 | const unsigned char *iv, int enc) | ||
112 | { | ||
113 | RC5_32_set_key(&(ctx->c.rc5.ks),EVP_CIPHER_CTX_key_length(ctx), | ||
114 | key,ctx->c.rc5.rounds); | ||
115 | return 1; | ||
116 | } | ||
117 | |||
118 | #endif | ||
diff --git a/src/lib/libcrypto/evp/evp_acnf.c b/src/lib/libcrypto/evp/evp_acnf.c new file mode 100644 index 0000000000..a68b979bdb --- /dev/null +++ b/src/lib/libcrypto/evp/evp_acnf.c | |||
@@ -0,0 +1,74 @@ | |||
1 | /* evp_acnf.c */ | ||
2 | /* Written by Stephen Henson (shenson@bigfoot.com) for the OpenSSL | ||
3 | * project 2001. | ||
4 | */ | ||
5 | /* ==================================================================== | ||
6 | * Copyright (c) 2001 The OpenSSL Project. All rights reserved. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * | ||
12 | * 1. Redistributions of source code must retain the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer. | ||
14 | * | ||
15 | * 2. Redistributions in binary form must reproduce the above copyright | ||
16 | * notice, this list of conditions and the following disclaimer in | ||
17 | * the documentation and/or other materials provided with the | ||
18 | * distribution. | ||
19 | * | ||
20 | * 3. All advertising materials mentioning features or use of this | ||
21 | * software must display the following acknowledgment: | ||
22 | * "This product includes software developed by the OpenSSL Project | ||
23 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
24 | * | ||
25 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
26 | * endorse or promote products derived from this software without | ||
27 | * prior written permission. For written permission, please contact | ||
28 | * licensing@OpenSSL.org. | ||
29 | * | ||
30 | * 5. Products derived from this software may not be called "OpenSSL" | ||
31 | * nor may "OpenSSL" appear in their names without prior written | ||
32 | * permission of the OpenSSL Project. | ||
33 | * | ||
34 | * 6. Redistributions of any form whatsoever must retain the following | ||
35 | * acknowledgment: | ||
36 | * "This product includes software developed by the OpenSSL Project | ||
37 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
38 | * | ||
39 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
40 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
41 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
42 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
43 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
45 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
46 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
47 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
48 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
49 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
50 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
51 | * ==================================================================== | ||
52 | * | ||
53 | * This product includes cryptographic software written by Eric Young | ||
54 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
55 | * Hudson (tjh@cryptsoft.com). | ||
56 | * | ||
57 | */ | ||
58 | |||
59 | #include "cryptlib.h" | ||
60 | #include <openssl/evp.h> | ||
61 | #include <openssl/conf.h> | ||
62 | #include <openssl/engine.h> | ||
63 | |||
64 | |||
65 | /* Load all algorithms and configure OpenSSL. | ||
66 | * This function is called automatically when | ||
67 | * OPENSSL_LOAD_CONF is set. | ||
68 | */ | ||
69 | |||
70 | void OPENSSL_add_all_algorithms_conf(void) | ||
71 | { | ||
72 | OPENSSL_add_all_algorithms_noconf(); | ||
73 | OPENSSL_config(NULL); | ||
74 | } | ||
diff --git a/src/lib/libcrypto/evp/evp_test.c b/src/lib/libcrypto/evp/evp_test.c new file mode 100644 index 0000000000..3607fe7776 --- /dev/null +++ b/src/lib/libcrypto/evp/evp_test.c | |||
@@ -0,0 +1,365 @@ | |||
1 | /* Written by Ben Laurie, 2001 */ | ||
2 | /* | ||
3 | * Copyright (c) 2001 The OpenSSL Project. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * | ||
9 | * 1. Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in | ||
14 | * the documentation and/or other materials provided with the | ||
15 | * distribution. | ||
16 | * | ||
17 | * 3. All advertising materials mentioning features or use of this | ||
18 | * software must display the following acknowledgment: | ||
19 | * "This product includes software developed by the OpenSSL Project | ||
20 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | ||
21 | * | ||
22 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
23 | * endorse or promote products derived from this software without | ||
24 | * prior written permission. For written permission, please contact | ||
25 | * openssl-core@openssl.org. | ||
26 | * | ||
27 | * 5. Products derived from this software may not be called "OpenSSL" | ||
28 | * nor may "OpenSSL" appear in their names without prior written | ||
29 | * permission of the OpenSSL Project. | ||
30 | * | ||
31 | * 6. Redistributions of any form whatsoever must retain the following | ||
32 | * acknowledgment: | ||
33 | * "This product includes software developed by the OpenSSL Project | ||
34 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | ||
35 | * | ||
36 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
37 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
39 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
40 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
42 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
43 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
44 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
45 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
46 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
47 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
48 | */ | ||
49 | |||
50 | #include <stdio.h> | ||
51 | #include <string.h> | ||
52 | #include <openssl/evp.h> | ||
53 | #include <openssl/engine.h> | ||
54 | #include <openssl/conf.h> | ||
55 | |||
56 | static void hexdump(FILE *f,const char *title,const unsigned char *s,int l) | ||
57 | { | ||
58 | int n=0; | ||
59 | |||
60 | fprintf(f,"%s",title); | ||
61 | for( ; n < l ; ++n) | ||
62 | { | ||
63 | if((n%16) == 0) | ||
64 | fprintf(f,"\n%04x",n); | ||
65 | fprintf(f," %02x",s[n]); | ||
66 | } | ||
67 | fprintf(f,"\n"); | ||
68 | } | ||
69 | |||
70 | static int convert(unsigned char *s) | ||
71 | { | ||
72 | unsigned char *d; | ||
73 | |||
74 | for(d=s ; *s ; s+=2,++d) | ||
75 | { | ||
76 | unsigned int n; | ||
77 | |||
78 | if(!s[1]) | ||
79 | { | ||
80 | fprintf(stderr,"Odd number of hex digits!"); | ||
81 | exit(4); | ||
82 | } | ||
83 | sscanf((char *)s,"%2x",&n); | ||
84 | *d=(unsigned char)n; | ||
85 | } | ||
86 | return s-d; | ||
87 | } | ||
88 | |||
89 | static char *sstrsep(char **string, const char *delim) | ||
90 | { | ||
91 | char isdelim[256]; | ||
92 | char *token = *string; | ||
93 | |||
94 | if (**string == 0) | ||
95 | return NULL; | ||
96 | |||
97 | memset(isdelim, 0, 256); | ||
98 | isdelim[0] = 1; | ||
99 | |||
100 | while (*delim) | ||
101 | { | ||
102 | isdelim[(unsigned char)(*delim)] = 1; | ||
103 | delim++; | ||
104 | } | ||
105 | |||
106 | while (!isdelim[(unsigned char)(**string)]) | ||
107 | { | ||
108 | (*string)++; | ||
109 | } | ||
110 | |||
111 | if (**string) | ||
112 | { | ||
113 | **string = 0; | ||
114 | (*string)++; | ||
115 | } | ||
116 | |||
117 | return token; | ||
118 | } | ||
119 | |||
120 | static unsigned char *ustrsep(char **p,const char *sep) | ||
121 | { return (unsigned char *)sstrsep((char **)p,sep); } | ||
122 | |||
123 | static void test1(const EVP_CIPHER *c,const unsigned char *key,int kn, | ||
124 | const unsigned char *iv,int in, | ||
125 | const unsigned char *plaintext,int pn, | ||
126 | const unsigned char *ciphertext,int cn) | ||
127 | { | ||
128 | EVP_CIPHER_CTX ctx; | ||
129 | unsigned char out[4096]; | ||
130 | int outl,outl2; | ||
131 | |||
132 | printf("Testing cipher %s\n",EVP_CIPHER_name(c)); | ||
133 | hexdump(stdout,"Key",key,kn); | ||
134 | if(in) | ||
135 | hexdump(stdout,"IV",iv,in); | ||
136 | hexdump(stdout,"Plaintext",plaintext,pn); | ||
137 | hexdump(stdout,"Ciphertext",ciphertext,cn); | ||
138 | |||
139 | if(kn != c->key_len) | ||
140 | { | ||
141 | fprintf(stderr,"Key length doesn't match, got %d expected %d\n",kn, | ||
142 | c->key_len); | ||
143 | exit(5); | ||
144 | } | ||
145 | EVP_CIPHER_CTX_init(&ctx); | ||
146 | if(!EVP_EncryptInit_ex(&ctx,c,NULL,key,iv)) | ||
147 | { | ||
148 | fprintf(stderr,"EncryptInit failed\n"); | ||
149 | exit(10); | ||
150 | } | ||
151 | EVP_CIPHER_CTX_set_padding(&ctx,0); | ||
152 | |||
153 | if(!EVP_EncryptUpdate(&ctx,out,&outl,plaintext,pn)) | ||
154 | { | ||
155 | fprintf(stderr,"Encrypt failed\n"); | ||
156 | exit(6); | ||
157 | } | ||
158 | if(!EVP_EncryptFinal_ex(&ctx,out+outl,&outl2)) | ||
159 | { | ||
160 | fprintf(stderr,"EncryptFinal failed\n"); | ||
161 | exit(7); | ||
162 | } | ||
163 | |||
164 | if(outl+outl2 != cn) | ||
165 | { | ||
166 | fprintf(stderr,"Ciphertext length mismatch got %d expected %d\n", | ||
167 | outl+outl2,cn); | ||
168 | exit(8); | ||
169 | } | ||
170 | |||
171 | if(memcmp(out,ciphertext,cn)) | ||
172 | { | ||
173 | fprintf(stderr,"Ciphertext mismatch\n"); | ||
174 | hexdump(stderr,"Got",out,cn); | ||
175 | hexdump(stderr,"Expected",ciphertext,cn); | ||
176 | exit(9); | ||
177 | } | ||
178 | |||
179 | if(!EVP_DecryptInit_ex(&ctx,c,NULL,key,iv)) | ||
180 | { | ||
181 | fprintf(stderr,"DecryptInit failed\n"); | ||
182 | exit(11); | ||
183 | } | ||
184 | EVP_CIPHER_CTX_set_padding(&ctx,0); | ||
185 | |||
186 | if(!EVP_DecryptUpdate(&ctx,out,&outl,ciphertext,pn)) | ||
187 | { | ||
188 | fprintf(stderr,"Decrypt failed\n"); | ||
189 | exit(6); | ||
190 | } | ||
191 | if(!EVP_DecryptFinal_ex(&ctx,out+outl,&outl2)) | ||
192 | { | ||
193 | fprintf(stderr,"DecryptFinal failed\n"); | ||
194 | exit(7); | ||
195 | } | ||
196 | |||
197 | if(outl+outl2 != cn) | ||
198 | { | ||
199 | fprintf(stderr,"Plaintext length mismatch got %d expected %d\n", | ||
200 | outl+outl2,cn); | ||
201 | exit(8); | ||
202 | } | ||
203 | |||
204 | if(memcmp(out,plaintext,cn)) | ||
205 | { | ||
206 | fprintf(stderr,"Plaintext mismatch\n"); | ||
207 | hexdump(stderr,"Got",out,cn); | ||
208 | hexdump(stderr,"Expected",plaintext,cn); | ||
209 | exit(9); | ||
210 | } | ||
211 | |||
212 | printf("\n"); | ||
213 | } | ||
214 | |||
215 | static int test_cipher(const char *cipher,const unsigned char *key,int kn, | ||
216 | const unsigned char *iv,int in, | ||
217 | const unsigned char *plaintext,int pn, | ||
218 | const unsigned char *ciphertext,int cn) | ||
219 | { | ||
220 | const EVP_CIPHER *c; | ||
221 | |||
222 | c=EVP_get_cipherbyname(cipher); | ||
223 | if(!c) | ||
224 | return 0; | ||
225 | |||
226 | test1(c,key,kn,iv,in,plaintext,pn,ciphertext,cn); | ||
227 | |||
228 | return 1; | ||
229 | } | ||
230 | |||
231 | static int test_digest(const char *digest, | ||
232 | const unsigned char *plaintext,int pn, | ||
233 | const unsigned char *ciphertext, unsigned int cn) | ||
234 | { | ||
235 | const EVP_MD *d; | ||
236 | EVP_MD_CTX ctx; | ||
237 | unsigned char md[EVP_MAX_MD_SIZE]; | ||
238 | unsigned int mdn; | ||
239 | |||
240 | d=EVP_get_digestbyname(digest); | ||
241 | if(!d) | ||
242 | return 0; | ||
243 | |||
244 | printf("Testing digest %s\n",EVP_MD_name(d)); | ||
245 | hexdump(stdout,"Plaintext",plaintext,pn); | ||
246 | hexdump(stdout,"Digest",ciphertext,cn); | ||
247 | |||
248 | EVP_MD_CTX_init(&ctx); | ||
249 | if(!EVP_DigestInit_ex(&ctx,d, NULL)) | ||
250 | { | ||
251 | fprintf(stderr,"DigestInit failed\n"); | ||
252 | exit(100); | ||
253 | } | ||
254 | if(!EVP_DigestUpdate(&ctx,plaintext,pn)) | ||
255 | { | ||
256 | fprintf(stderr,"DigestUpdate failed\n"); | ||
257 | exit(101); | ||
258 | } | ||
259 | if(!EVP_DigestFinal_ex(&ctx,md,&mdn)) | ||
260 | { | ||
261 | fprintf(stderr,"DigestFinal failed\n"); | ||
262 | exit(101); | ||
263 | } | ||
264 | EVP_MD_CTX_cleanup(&ctx); | ||
265 | |||
266 | if(mdn != cn) | ||
267 | { | ||
268 | fprintf(stderr,"Digest length mismatch, got %d expected %d\n",mdn,cn); | ||
269 | exit(102); | ||
270 | } | ||
271 | |||
272 | if(memcmp(md,ciphertext,cn)) | ||
273 | { | ||
274 | fprintf(stderr,"Digest mismatch\n"); | ||
275 | hexdump(stderr,"Got",md,cn); | ||
276 | hexdump(stderr,"Expected",ciphertext,cn); | ||
277 | exit(103); | ||
278 | } | ||
279 | |||
280 | printf("\n"); | ||
281 | |||
282 | return 1; | ||
283 | } | ||
284 | |||
285 | int main(int argc,char **argv) | ||
286 | { | ||
287 | const char *szTestFile; | ||
288 | FILE *f; | ||
289 | |||
290 | if(argc != 2) | ||
291 | { | ||
292 | fprintf(stderr,"%s <test file>\n",argv[0]); | ||
293 | exit(1); | ||
294 | } | ||
295 | CRYPTO_malloc_debug_init(); | ||
296 | CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL); | ||
297 | CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); | ||
298 | |||
299 | szTestFile=argv[1]; | ||
300 | |||
301 | f=fopen(szTestFile,"r"); | ||
302 | if(!f) | ||
303 | { | ||
304 | perror(szTestFile); | ||
305 | exit(2); | ||
306 | } | ||
307 | |||
308 | /* Load up the software EVP_CIPHER and EVP_MD definitions */ | ||
309 | OpenSSL_add_all_ciphers(); | ||
310 | OpenSSL_add_all_digests(); | ||
311 | /* Load all compiled-in ENGINEs */ | ||
312 | ENGINE_load_builtin_engines(); | ||
313 | #if 0 | ||
314 | OPENSSL_config(); | ||
315 | #endif | ||
316 | /* Register all available ENGINE implementations of ciphers and digests. | ||
317 | * This could perhaps be changed to "ENGINE_register_all_complete()"? */ | ||
318 | ENGINE_register_all_ciphers(); | ||
319 | ENGINE_register_all_digests(); | ||
320 | /* If we add command-line options, this statement should be switchable. | ||
321 | * It'll prevent ENGINEs being ENGINE_init()ialised for cipher/digest use if | ||
322 | * they weren't already initialised. */ | ||
323 | /* ENGINE_set_cipher_flags(ENGINE_CIPHER_FLAG_NOINIT); */ | ||
324 | |||
325 | for( ; ; ) | ||
326 | { | ||
327 | char line[4096]; | ||
328 | char *p; | ||
329 | char *cipher; | ||
330 | unsigned char *iv,*key,*plaintext,*ciphertext; | ||
331 | int kn,in,pn,cn; | ||
332 | |||
333 | if(!fgets((char *)line,sizeof line,f)) | ||
334 | break; | ||
335 | if(line[0] == '#' || line[0] == '\n') | ||
336 | continue; | ||
337 | p=line; | ||
338 | cipher=sstrsep(&p,":"); | ||
339 | key=ustrsep(&p,":"); | ||
340 | iv=ustrsep(&p,":"); | ||
341 | plaintext=ustrsep(&p,":"); | ||
342 | ciphertext=ustrsep(&p,"\n"); | ||
343 | |||
344 | kn=convert(key); | ||
345 | in=convert(iv); | ||
346 | pn=convert(plaintext); | ||
347 | cn=convert(ciphertext); | ||
348 | |||
349 | if(!test_cipher(cipher,key,kn,iv,in,plaintext,pn,ciphertext,cn) | ||
350 | && !test_digest(cipher,plaintext,pn,ciphertext,cn)) | ||
351 | { | ||
352 | fprintf(stderr,"Can't find %s\n",cipher); | ||
353 | exit(3); | ||
354 | } | ||
355 | } | ||
356 | |||
357 | ENGINE_cleanup(); | ||
358 | EVP_cleanup(); | ||
359 | CRYPTO_cleanup_all_ex_data(); | ||
360 | ERR_remove_state(0); | ||
361 | ERR_free_strings(); | ||
362 | CRYPTO_mem_leaks_fp(stderr); | ||
363 | |||
364 | return 0; | ||
365 | } | ||
diff --git a/src/lib/libcrypto/evp/evptests.txt b/src/lib/libcrypto/evp/evptests.txt new file mode 100644 index 0000000000..6c1529db37 --- /dev/null +++ b/src/lib/libcrypto/evp/evptests.txt | |||
@@ -0,0 +1,82 @@ | |||
1 | #cipher:key:iv:input:output | ||
2 | #digest:::input:output | ||
3 | |||
4 | # SHA(1) tests (from shatest.c) | ||
5 | SHA1:::616263:a9993e364706816aba3e25717850c26c9cd0d89d | ||
6 | |||
7 | # MD5 tests (from md5test.c) | ||
8 | MD5::::d41d8cd98f00b204e9800998ecf8427e | ||
9 | MD5:::61:0cc175b9c0f1b6a831c399e269772661 | ||
10 | MD5:::616263:900150983cd24fb0d6963f7d28e17f72 | ||
11 | MD5:::6d65737361676520646967657374:f96b697d7cb7938d525a2f31aaf161d0 | ||
12 | MD5:::6162636465666768696a6b6c6d6e6f707172737475767778797a:c3fcd3d76192e4007dfb496cca67e13b | ||
13 | MD5:::4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a30313233343536373839:d174ab98d277d9f5a5611c2c9f419d9f | ||
14 | MD5:::3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930:57edf4a22be3c955ac49da2e2107b67a | ||
15 | |||
16 | # AES 128 ECB tests (from FIPS-197 test vectors, encrypt) | ||
17 | |||
18 | AES-128-ECB:000102030405060708090A0B0C0D0E0F::00112233445566778899AABBCCDDEEFF:69C4E0D86A7B0430D8CDB78070B4C55A | ||
19 | |||
20 | # AES 192 ECB tests (from FIPS-197 test vectors, encrypt) | ||
21 | |||
22 | AES-192-ECB:000102030405060708090A0B0C0D0E0F1011121314151617::00112233445566778899AABBCCDDEEFF:DDA97CA4864CDFE06EAF70A0EC0D7191 | ||
23 | |||
24 | # AES 256 ECB tests (from FIPS-197 test vectors, encrypt) | ||
25 | |||
26 | AES-256-ECB:000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F::00112233445566778899AABBCCDDEEFF:8EA2B7CA516745BFEAFC49904B496089 | ||
27 | |||
28 | # AES 128 ECB tests (from NIST test vectors, encrypt) | ||
29 | |||
30 | #AES-128-ECB:00000000000000000000000000000000::00000000000000000000000000000000:C34C052CC0DA8D73451AFE5F03BE297F | ||
31 | |||
32 | # AES 128 ECB tests (from NIST test vectors, decrypt) | ||
33 | |||
34 | #AES-128-ECB:00000000000000000000000000000000::44416AC2D1F53C583303917E6BE9EBE0:00000000000000000000000000000000 | ||
35 | |||
36 | # AES 192 ECB tests (from NIST test vectors, decrypt) | ||
37 | |||
38 | #AES-192-ECB:000000000000000000000000000000000000000000000000::48E31E9E256718F29229319C19F15BA4:00000000000000000000000000000000 | ||
39 | |||
40 | # AES 256 ECB tests (from NIST test vectors, decrypt) | ||
41 | |||
42 | #AES-256-ECB:0000000000000000000000000000000000000000000000000000000000000000::058CCFFDBBCB382D1F6F56585D8A4ADE:00000000000000000000000000000000 | ||
43 | |||
44 | # AES 128 CBC tests (from NIST test vectors, encrypt) | ||
45 | |||
46 | #AES-128-CBC:00000000000000000000000000000000:00000000000000000000000000000000:00000000000000000000000000000000:8A05FC5E095AF4848A08D328D3688E3D | ||
47 | |||
48 | # AES 192 CBC tests (from NIST test vectors, encrypt) | ||
49 | |||
50 | #AES-192-CBC:000000000000000000000000000000000000000000000000:00000000000000000000000000000000:00000000000000000000000000000000:7BD966D53AD8C1BB85D2ADFAE87BB104 | ||
51 | |||
52 | # AES 256 CBC tests (from NIST test vectors, encrypt) | ||
53 | |||
54 | #AES-256-CBC:0000000000000000000000000000000000000000000000000000000000000000:00000000000000000000000000000000:00000000000000000000000000000000:FE3C53653E2F45B56FCD88B2CC898FF0 | ||
55 | |||
56 | # AES 128 CBC tests (from NIST test vectors, decrypt) | ||
57 | |||
58 | #AES-128-CBC:00000000000000000000000000000000:00000000000000000000000000000000:FACA37E0B0C85373DF706E73F7C9AF86:00000000000000000000000000000000 | ||
59 | |||
60 | # DES ECB tests (from destest) | ||
61 | |||
62 | DES-ECB:0000000000000000::0000000000000000:8CA64DE9C1B123A7 | ||
63 | DES-ECB:FFFFFFFFFFFFFFFF::FFFFFFFFFFFFFFFF:7359B2163E4EDC58 | ||
64 | DES-ECB:3000000000000000::1000000000000001:958E6E627A05557B | ||
65 | DES-ECB:1111111111111111::1111111111111111:F40379AB9E0EC533 | ||
66 | DES-ECB:0123456789ABCDEF::1111111111111111:17668DFC7292532D | ||
67 | DES-ECB:1111111111111111::0123456789ABCDEF:8A5AE1F81AB8F2DD | ||
68 | DES-ECB:FEDCBA9876543210::0123456789ABCDEF:ED39D950FA74BCC4 | ||
69 | |||
70 | # DESX-CBC tests (from destest) | ||
71 | DESX-CBC:0123456789abcdeff1e0d3c2b5a49786fedcba9876543210:fedcba9876543210:37363534333231204E6F77206973207468652074696D6520666F722000000000:846B2914851E9A2954732F8AA0A611C115CDC2D7951B1053A63C5E03B21AA3C4 | ||
72 | |||
73 | # DES EDE3 CBC tests (from destest) | ||
74 | DES-EDE3-CBC:0123456789abcdeff1e0d3c2b5a49786fedcba9876543210:fedcba9876543210:37363534333231204E6F77206973207468652074696D6520666F722000000000:3FE301C962AC01D02213763C1CBD4CDC799657C064ECF5D41C673812CFDE9675 | ||
75 | |||
76 | # RC4 tests (from rc4test) | ||
77 | RC4:0123456789abcdef0123456789abcdef::0123456789abcdef:75b7878099e0c596 | ||
78 | RC4:0123456789abcdef0123456789abcdef::0000000000000000:7494c2e7104b0879 | ||
79 | RC4:00000000000000000000000000000000::0000000000000000:de188941a3375d3a | ||
80 | RC4:ef012345ef012345ef012345ef012345::0000000000000000000000000000000000000000:d6a141a7ec3c38dfbd615a1162e1c7ba36b67858 | ||
81 | RC4:0123456789abcdef0123456789abcdef::123456789ABCDEF0123456789ABCDEF0123456789ABCDEF012345678:66a0949f8af7d6891f7f832ba833c00c892ebe30143ce28740011ecf | ||
82 | RC4:ef012345ef012345ef012345ef012345::00000000000000000000:d6a141a7ec3c38dfbd61 | ||
diff --git a/src/lib/libcrypto/evp/openbsd_hw.c b/src/lib/libcrypto/evp/openbsd_hw.c new file mode 100644 index 0000000000..3831a5731e --- /dev/null +++ b/src/lib/libcrypto/evp/openbsd_hw.c | |||
@@ -0,0 +1,446 @@ | |||
1 | /* Written by Ben Laurie, 2001 */ | ||
2 | /* | ||
3 | * Copyright (c) 2001 The OpenSSL Project. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * | ||
9 | * 1. Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in | ||
14 | * the documentation and/or other materials provided with the | ||
15 | * distribution. | ||
16 | * | ||
17 | * 3. All advertising materials mentioning features or use of this | ||
18 | * software must display the following acknowledgment: | ||
19 | * "This product includes software developed by the OpenSSL Project | ||
20 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | ||
21 | * | ||
22 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
23 | * endorse or promote products derived from this software without | ||
24 | * prior written permission. For written permission, please contact | ||
25 | * openssl-core@openssl.org. | ||
26 | * | ||
27 | * 5. Products derived from this software may not be called "OpenSSL" | ||
28 | * nor may "OpenSSL" appear in their names without prior written | ||
29 | * permission of the OpenSSL Project. | ||
30 | * | ||
31 | * 6. Redistributions of any form whatsoever must retain the following | ||
32 | * acknowledgment: | ||
33 | * "This product includes software developed by the OpenSSL Project | ||
34 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | ||
35 | * | ||
36 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
37 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
39 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
40 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
42 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
43 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
44 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
45 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
46 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
47 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
48 | */ | ||
49 | |||
50 | #include <openssl/evp.h> | ||
51 | #include <openssl/objects.h> | ||
52 | #include <openssl/rsa.h> | ||
53 | #include "evp_locl.h" | ||
54 | |||
55 | /* This stuff should now all be supported through | ||
56 | * crypto/engine/hw_openbsd_dev_crypto.c unless I botched it up */ | ||
57 | static void *dummy=&dummy; | ||
58 | |||
59 | #if 0 | ||
60 | |||
61 | /* check flag after OpenSSL headers to ensure make depend works */ | ||
62 | #ifdef OPENSSL_OPENBSD_DEV_CRYPTO | ||
63 | |||
64 | #include <fcntl.h> | ||
65 | #include <stdio.h> | ||
66 | #include <errno.h> | ||
67 | #include <sys/ioctl.h> | ||
68 | #include <crypto/cryptodev.h> | ||
69 | #include <unistd.h> | ||
70 | #include <assert.h> | ||
71 | |||
72 | /* longest key supported in hardware */ | ||
73 | #define MAX_HW_KEY 24 | ||
74 | #define MAX_HW_IV 8 | ||
75 | |||
76 | #define MD5_DIGEST_LENGTH 16 | ||
77 | #define MD5_CBLOCK 64 | ||
78 | |||
79 | static int fd; | ||
80 | static int dev_failed; | ||
81 | |||
82 | typedef struct session_op session_op; | ||
83 | |||
84 | #define CDATA(ctx) EVP_C_DATA(session_op,ctx) | ||
85 | |||
86 | static void err(const char *str) | ||
87 | { | ||
88 | fprintf(stderr,"%s: errno %d\n",str,errno); | ||
89 | } | ||
90 | |||
91 | static int dev_crypto_init(session_op *ses) | ||
92 | { | ||
93 | if(dev_failed) | ||
94 | return 0; | ||
95 | if(!fd) | ||
96 | { | ||
97 | int cryptodev_fd; | ||
98 | |||
99 | if ((cryptodev_fd=open("/dev/crypto",O_RDWR,0)) < 0) | ||
100 | { | ||
101 | err("/dev/crypto"); | ||
102 | dev_failed=1; | ||
103 | return 0; | ||
104 | } | ||
105 | if (ioctl(cryptodev_fd,CRIOGET,&fd) == -1) | ||
106 | { | ||
107 | err("CRIOGET failed"); | ||
108 | close(cryptodev_fd); | ||
109 | dev_failed=1; | ||
110 | return 0; | ||
111 | } | ||
112 | close(cryptodev_fd); | ||
113 | } | ||
114 | assert(ses); | ||
115 | memset(ses,'\0',sizeof *ses); | ||
116 | |||
117 | return 1; | ||
118 | } | ||
119 | |||
120 | static int dev_crypto_cleanup(EVP_CIPHER_CTX *ctx) | ||
121 | { | ||
122 | if(ioctl(fd,CIOCFSESSION,&CDATA(ctx)->ses) == -1) | ||
123 | err("CIOCFSESSION failed"); | ||
124 | |||
125 | OPENSSL_free(CDATA(ctx)->key); | ||
126 | |||
127 | return 1; | ||
128 | } | ||
129 | |||
130 | static int dev_crypto_init_key(EVP_CIPHER_CTX *ctx,int cipher, | ||
131 | const unsigned char *key,int klen) | ||
132 | { | ||
133 | if(!dev_crypto_init(CDATA(ctx))) | ||
134 | return 0; | ||
135 | |||
136 | CDATA(ctx)->key=OPENSSL_malloc(MAX_HW_KEY); | ||
137 | |||
138 | assert(ctx->cipher->iv_len <= MAX_HW_IV); | ||
139 | |||
140 | memcpy(CDATA(ctx)->key,key,klen); | ||
141 | |||
142 | CDATA(ctx)->cipher=cipher; | ||
143 | CDATA(ctx)->keylen=klen; | ||
144 | |||
145 | if (ioctl(fd,CIOCGSESSION,CDATA(ctx)) == -1) | ||
146 | { | ||
147 | err("CIOCGSESSION failed"); | ||
148 | return 0; | ||
149 | } | ||
150 | return 1; | ||
151 | } | ||
152 | |||
153 | static int dev_crypto_cipher(EVP_CIPHER_CTX *ctx,unsigned char *out, | ||
154 | const unsigned char *in,unsigned int inl) | ||
155 | { | ||
156 | struct crypt_op cryp; | ||
157 | unsigned char lb[MAX_HW_IV]; | ||
158 | |||
159 | if(!inl) | ||
160 | return 1; | ||
161 | |||
162 | assert(CDATA(ctx)); | ||
163 | assert(!dev_failed); | ||
164 | |||
165 | memset(&cryp,'\0',sizeof cryp); | ||
166 | cryp.ses=CDATA(ctx)->ses; | ||
167 | cryp.op=ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT; | ||
168 | cryp.flags=0; | ||
169 | cryp.len=inl; | ||
170 | assert((inl&(ctx->cipher->block_size-1)) == 0); | ||
171 | cryp.src=(caddr_t)in; | ||
172 | cryp.dst=(caddr_t)out; | ||
173 | cryp.mac=0; | ||
174 | if(ctx->cipher->iv_len) | ||
175 | cryp.iv=(caddr_t)ctx->iv; | ||
176 | |||
177 | if(!ctx->encrypt) | ||
178 | memcpy(lb,&in[cryp.len-ctx->cipher->iv_len],ctx->cipher->iv_len); | ||
179 | |||
180 | if(ioctl(fd, CIOCCRYPT, &cryp) == -1) | ||
181 | { | ||
182 | if(errno == EINVAL) /* buffers are misaligned */ | ||
183 | { | ||
184 | unsigned int cinl=0; | ||
185 | char *cin=NULL; | ||
186 | char *cout=NULL; | ||
187 | |||
188 | /* NB: this can only make cinl != inl with stream ciphers */ | ||
189 | cinl=(inl+3)/4*4; | ||
190 | |||
191 | if(((unsigned long)in&3) || cinl != inl) | ||
192 | { | ||
193 | cin=OPENSSL_malloc(cinl); | ||
194 | memcpy(cin,in,inl); | ||
195 | cryp.src=cin; | ||
196 | } | ||
197 | |||
198 | if(((unsigned long)out&3) || cinl != inl) | ||
199 | { | ||
200 | cout=OPENSSL_malloc(cinl); | ||
201 | cryp.dst=cout; | ||
202 | } | ||
203 | |||
204 | cryp.len=cinl; | ||
205 | |||
206 | if(ioctl(fd, CIOCCRYPT, &cryp) == -1) | ||
207 | { | ||
208 | err("CIOCCRYPT(2) failed"); | ||
209 | printf("src=%p dst=%p\n",cryp.src,cryp.dst); | ||
210 | abort(); | ||
211 | return 0; | ||
212 | } | ||
213 | |||
214 | if(cout) | ||
215 | { | ||
216 | memcpy(out,cout,inl); | ||
217 | OPENSSL_free(cout); | ||
218 | } | ||
219 | if(cin) | ||
220 | OPENSSL_free(cin); | ||
221 | } | ||
222 | else | ||
223 | { | ||
224 | err("CIOCCRYPT failed"); | ||
225 | abort(); | ||
226 | return 0; | ||
227 | } | ||
228 | } | ||
229 | |||
230 | if(ctx->encrypt) | ||
231 | memcpy(ctx->iv,&out[cryp.len-ctx->cipher->iv_len],ctx->cipher->iv_len); | ||
232 | else | ||
233 | memcpy(ctx->iv,lb,ctx->cipher->iv_len); | ||
234 | |||
235 | return 1; | ||
236 | } | ||
237 | |||
238 | static int dev_crypto_des_ede3_init_key(EVP_CIPHER_CTX *ctx, | ||
239 | const unsigned char *key, | ||
240 | const unsigned char *iv, int enc) | ||
241 | { return dev_crypto_init_key(ctx,CRYPTO_3DES_CBC,key,24); } | ||
242 | |||
243 | #define dev_crypto_des_ede3_cbc_cipher dev_crypto_cipher | ||
244 | |||
245 | BLOCK_CIPHER_def_cbc(dev_crypto_des_ede3, session_op, NID_des_ede3, 8, 24, 8, | ||
246 | 0, dev_crypto_des_ede3_init_key, | ||
247 | dev_crypto_cleanup, | ||
248 | EVP_CIPHER_set_asn1_iv, | ||
249 | EVP_CIPHER_get_asn1_iv, | ||
250 | NULL) | ||
251 | |||
252 | static int dev_crypto_rc4_init_key(EVP_CIPHER_CTX *ctx, | ||
253 | const unsigned char *key, | ||
254 | const unsigned char *iv, int enc) | ||
255 | { return dev_crypto_init_key(ctx,CRYPTO_ARC4,key,16); } | ||
256 | |||
257 | static const EVP_CIPHER r4_cipher= | ||
258 | { | ||
259 | NID_rc4, | ||
260 | 1,16,0, /* FIXME: key should be up to 256 bytes */ | ||
261 | EVP_CIPH_VARIABLE_LENGTH, | ||
262 | dev_crypto_rc4_init_key, | ||
263 | dev_crypto_cipher, | ||
264 | dev_crypto_cleanup, | ||
265 | sizeof(session_op), | ||
266 | NULL, | ||
267 | NULL, | ||
268 | NULL | ||
269 | }; | ||
270 | |||
271 | const EVP_CIPHER *EVP_dev_crypto_rc4(void) | ||
272 | { return &r4_cipher; } | ||
273 | |||
274 | typedef struct | ||
275 | { | ||
276 | session_op sess; | ||
277 | char *data; | ||
278 | int len; | ||
279 | unsigned char md[EVP_MAX_MD_SIZE]; | ||
280 | } MD_DATA; | ||
281 | |||
282 | static int dev_crypto_init_digest(MD_DATA *md_data,int mac) | ||
283 | { | ||
284 | if(!dev_crypto_init(&md_data->sess)) | ||
285 | return 0; | ||
286 | |||
287 | md_data->len=0; | ||
288 | md_data->data=NULL; | ||
289 | |||
290 | md_data->sess.mac=mac; | ||
291 | |||
292 | if (ioctl(fd,CIOCGSESSION,&md_data->sess) == -1) | ||
293 | { | ||
294 | err("CIOCGSESSION failed"); | ||
295 | return 0; | ||
296 | } | ||
297 | return 1; | ||
298 | } | ||
299 | |||
300 | static int dev_crypto_cleanup_digest(MD_DATA *md_data) | ||
301 | { | ||
302 | if (ioctl(fd,CIOCFSESSION,&md_data->sess.ses) == -1) | ||
303 | { | ||
304 | err("CIOCFSESSION failed"); | ||
305 | return 0; | ||
306 | } | ||
307 | |||
308 | return 1; | ||
309 | } | ||
310 | |||
311 | /* FIXME: if device can do chained MACs, then don't accumulate */ | ||
312 | /* FIXME: move accumulation to the framework */ | ||
313 | static int dev_crypto_md5_init(EVP_MD_CTX *ctx) | ||
314 | { return dev_crypto_init_digest(ctx->md_data,CRYPTO_MD5); } | ||
315 | |||
316 | static int do_digest(int ses,unsigned char *md,const void *data,int len) | ||
317 | { | ||
318 | struct crypt_op cryp; | ||
319 | static unsigned char md5zero[16]= | ||
320 | { | ||
321 | 0xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04, | ||
322 | 0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,0x7e | ||
323 | }; | ||
324 | |||
325 | /* some cards can't do zero length */ | ||
326 | if(!len) | ||
327 | { | ||
328 | memcpy(md,md5zero,16); | ||
329 | return 1; | ||
330 | } | ||
331 | |||
332 | memset(&cryp,'\0',sizeof cryp); | ||
333 | cryp.ses=ses; | ||
334 | cryp.op=COP_ENCRYPT;/* required to do the MAC rather than check it */ | ||
335 | cryp.len=len; | ||
336 | cryp.src=(caddr_t)data; | ||
337 | cryp.dst=(caddr_t)data; // FIXME!!! | ||
338 | cryp.mac=(caddr_t)md; | ||
339 | |||
340 | if(ioctl(fd, CIOCCRYPT, &cryp) == -1) | ||
341 | { | ||
342 | if(errno == EINVAL) /* buffer is misaligned */ | ||
343 | { | ||
344 | char *dcopy; | ||
345 | |||
346 | dcopy=OPENSSL_malloc(len); | ||
347 | memcpy(dcopy,data,len); | ||
348 | cryp.src=dcopy; | ||
349 | cryp.dst=cryp.src; // FIXME!!! | ||
350 | |||
351 | if(ioctl(fd, CIOCCRYPT, &cryp) == -1) | ||
352 | { | ||
353 | err("CIOCCRYPT(MAC2) failed"); | ||
354 | abort(); | ||
355 | return 0; | ||
356 | } | ||
357 | OPENSSL_free(dcopy); | ||
358 | } | ||
359 | else | ||
360 | { | ||
361 | err("CIOCCRYPT(MAC) failed"); | ||
362 | abort(); | ||
363 | return 0; | ||
364 | } | ||
365 | } | ||
366 | // printf("done\n"); | ||
367 | |||
368 | return 1; | ||
369 | } | ||
370 | |||
371 | static int dev_crypto_md5_update(EVP_MD_CTX *ctx,const void *data, | ||
372 | unsigned long len) | ||
373 | { | ||
374 | MD_DATA *md_data=ctx->md_data; | ||
375 | |||
376 | if(ctx->flags&EVP_MD_CTX_FLAG_ONESHOT) | ||
377 | return do_digest(md_data->sess.ses,md_data->md,data,len); | ||
378 | |||
379 | md_data->data=OPENSSL_realloc(md_data->data,md_data->len+len); | ||
380 | memcpy(md_data->data+md_data->len,data,len); | ||
381 | md_data->len+=len; | ||
382 | |||
383 | return 1; | ||
384 | } | ||
385 | |||
386 | static int dev_crypto_md5_final(EVP_MD_CTX *ctx,unsigned char *md) | ||
387 | { | ||
388 | int ret; | ||
389 | MD_DATA *md_data=ctx->md_data; | ||
390 | |||
391 | if(ctx->flags&EVP_MD_CTX_FLAG_ONESHOT) | ||
392 | { | ||
393 | memcpy(md,md_data->md,MD5_DIGEST_LENGTH); | ||
394 | ret=1; | ||
395 | } | ||
396 | else | ||
397 | { | ||
398 | ret=do_digest(md_data->sess.ses,md,md_data->data,md_data->len); | ||
399 | OPENSSL_free(md_data->data); | ||
400 | md_data->data=NULL; | ||
401 | md_data->len=0; | ||
402 | } | ||
403 | |||
404 | return ret; | ||
405 | } | ||
406 | |||
407 | static int dev_crypto_md5_copy(EVP_MD_CTX *to,const EVP_MD_CTX *from) | ||
408 | { | ||
409 | const MD_DATA *from_md=from->md_data; | ||
410 | MD_DATA *to_md=to->md_data; | ||
411 | |||
412 | // How do we copy sessions? | ||
413 | assert(from->digest->flags&EVP_MD_FLAG_ONESHOT); | ||
414 | |||
415 | to_md->data=OPENSSL_malloc(from_md->len); | ||
416 | memcpy(to_md->data,from_md->data,from_md->len); | ||
417 | |||
418 | return 1; | ||
419 | } | ||
420 | |||
421 | static int dev_crypto_md5_cleanup(EVP_MD_CTX *ctx) | ||
422 | { | ||
423 | return dev_crypto_cleanup_digest(ctx->md_data); | ||
424 | } | ||
425 | |||
426 | static const EVP_MD md5_md= | ||
427 | { | ||
428 | NID_md5, | ||
429 | NID_md5WithRSAEncryption, | ||
430 | MD5_DIGEST_LENGTH, | ||
431 | EVP_MD_FLAG_ONESHOT, // XXX: set according to device info... | ||
432 | dev_crypto_md5_init, | ||
433 | dev_crypto_md5_update, | ||
434 | dev_crypto_md5_final, | ||
435 | dev_crypto_md5_copy, | ||
436 | dev_crypto_md5_cleanup, | ||
437 | EVP_PKEY_RSA_method, | ||
438 | MD5_CBLOCK, | ||
439 | sizeof(MD_DATA), | ||
440 | }; | ||
441 | |||
442 | const EVP_MD *EVP_dev_crypto_md5(void) | ||
443 | { return &md5_md; } | ||
444 | |||
445 | #endif | ||
446 | #endif | ||