Branch data Line data Source code
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 : :
53 : : #include "../e_os.h"
54 : :
55 : : #include <openssl/opensslconf.h>
56 : : #include <openssl/evp.h>
57 : : #ifndef OPENSSL_NO_ENGINE
58 : : #include <openssl/engine.h>
59 : : #endif
60 : : #include <openssl/err.h>
61 : : #include <openssl/conf.h>
62 : :
63 : 944 : static void hexdump(FILE *f,const char *title,const unsigned char *s,int l)
64 : : {
65 : 944 : int n=0;
66 : :
67 : : fprintf(f,"%s",title);
68 [ + + ]: 33077 : for( ; n < l ; ++n)
69 : : {
70 [ + + ]: 32133 : if((n%16) == 0)
71 : : fprintf(f,"\n%04x",n);
72 : 32133 : fprintf(f," %02x",s[n]);
73 : : }
74 : : fprintf(f,"\n");
75 : 944 : }
76 : :
77 : 1036 : static int convert(unsigned char *s)
78 : : {
79 : : unsigned char *d;
80 : :
81 [ + + ]: 33169 : for(d=s ; *s ; s+=2,++d)
82 : : {
83 : : unsigned int n;
84 : :
85 [ - + ]: 32133 : if(!s[1])
86 : : {
87 : 0 : fprintf(stderr,"Odd number of hex digits!");
88 : 0 : EXIT(4);
89 : : }
90 : 32133 : sscanf((char *)s,"%2x",&n);
91 : 32133 : *d=(unsigned char)n;
92 : : }
93 : 1036 : return s-d;
94 : : }
95 : :
96 : 1639 : static char *sstrsep(char **string, const char *delim)
97 : : {
98 : : char isdelim[256];
99 : 1639 : char *token = *string;
100 : :
101 [ + + ]: 1639 : if (**string == 0)
102 : : return NULL;
103 : :
104 : : memset(isdelim, 0, 256);
105 : 1520 : isdelim[0] = 1;
106 : :
107 [ + + ]: 3040 : while (*delim)
108 : : {
109 : 1520 : isdelim[(unsigned char)(*delim)] = 1;
110 : 1520 : delim++;
111 : : }
112 : :
113 [ + + ]: 69257 : while (!isdelim[(unsigned char)(**string)])
114 : : {
115 : 67737 : (*string)++;
116 : : }
117 : :
118 [ + + ]: 1520 : if (**string)
119 : : {
120 : 1274 : **string = 0;
121 : 1274 : (*string)++;
122 : : }
123 : :
124 : 1520 : return token;
125 : : }
126 : :
127 : 1274 : static unsigned char *ustrsep(char **p,const char *sep)
128 : 1274 : { return (unsigned char *)sstrsep(p,sep); }
129 : :
130 : 0 : static int test1_exit(int ec)
131 : : {
132 : 0 : EXIT(ec);
133 : : return(0); /* To keep some compilers quiet */
134 : : }
135 : :
136 : : /* Test copying of contexts */
137 : 357 : static void test_ctx_replace(EVP_CIPHER_CTX **pctx)
138 : : {
139 : : /* Make copy of context and replace original */
140 : : EVP_CIPHER_CTX *ctx_copy;
141 : 357 : ctx_copy = EVP_CIPHER_CTX_new();
142 : 357 : EVP_CIPHER_CTX_copy(ctx_copy, *pctx);
143 : 357 : EVP_CIPHER_CTX_free(*pctx);
144 : 357 : *pctx = ctx_copy;
145 : 357 : }
146 : :
147 : 238 : static void test1(const EVP_CIPHER *c,const unsigned char *key,int kn,
148 : : const unsigned char *iv,int in,
149 : : const unsigned char *plaintext,int pn,
150 : : const unsigned char *ciphertext,int cn,
151 : : const unsigned char *aad,int an,
152 : : const unsigned char *tag,int tn,
153 : : int encdec)
154 : : {
155 : 238 : EVP_CIPHER_CTX *ctx = NULL;
156 : : unsigned char out[4096];
157 : : int outl,outl2,mode;
158 : :
159 [ + + ]: 409 : printf("Testing cipher %s%s\n",EVP_CIPHER_name(c),
160 [ + + ]: 171 : (encdec == 1 ? "(encrypt)" : (encdec == 0 ? "(decrypt)" : "(encrypt/decrypt)")));
161 : 238 : hexdump(stdout,"Key",key,kn);
162 [ + + ]: 238 : if(in)
163 : 176 : hexdump(stdout,"IV",iv,in);
164 : 238 : hexdump(stdout,"Plaintext",plaintext,pn);
165 : 238 : hexdump(stdout,"Ciphertext",ciphertext,cn);
166 [ + + ]: 238 : if (an)
167 : 12 : hexdump(stdout,"AAD",aad,an);
168 [ + + ]: 238 : if (tn)
169 : 26 : hexdump(stdout,"Tag",tag,tn);
170 : 238 : mode = EVP_CIPHER_mode(c);
171 [ - + ]: 238 : if(kn != EVP_CIPHER_key_length(c))
172 : : {
173 : 0 : fprintf(stderr,"Key length doesn't match, got %d expected %lu\n",kn,
174 : 0 : (unsigned long)EVP_CIPHER_key_length(c));
175 : 0 : test1_exit(5);
176 : : }
177 : 238 : ctx = EVP_CIPHER_CTX_new();
178 : 238 : EVP_CIPHER_CTX_set_flags(ctx,EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
179 [ + + ]: 238 : if (encdec != 0)
180 : : {
181 [ + + ]: 186 : if (mode == EVP_CIPH_GCM_MODE)
182 : : {
183 [ - + ]: 25 : if(!EVP_EncryptInit_ex(ctx,c,NULL,NULL,NULL))
184 : : {
185 : 0 : fprintf(stderr,"EncryptInit failed\n");
186 : 0 : ERR_print_errors_fp(stderr);
187 : 0 : test1_exit(10);
188 : : }
189 [ - + ]: 25 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, in, NULL))
190 : : {
191 : 0 : fprintf(stderr,"IV length set failed\n");
192 : 0 : ERR_print_errors_fp(stderr);
193 : 0 : test1_exit(11);
194 : : }
195 [ - + ]: 25 : if(!EVP_EncryptInit_ex(ctx,NULL,NULL,key,iv))
196 : : {
197 : 0 : fprintf(stderr,"Key/IV set failed\n");
198 : 0 : ERR_print_errors_fp(stderr);
199 : 0 : test1_exit(12);
200 : : }
201 [ + + ][ - + ]: 25 : if (an && !EVP_EncryptUpdate(ctx,NULL,&outl,aad,an))
202 : : {
203 : 0 : fprintf(stderr,"AAD set failed\n");
204 : 0 : ERR_print_errors_fp(stderr);
205 : 0 : test1_exit(13);
206 : : }
207 : : }
208 [ + + ]: 161 : else if (mode == EVP_CIPH_CCM_MODE)
209 : : {
210 [ - + ]: 1 : if(!EVP_EncryptInit_ex(ctx,c,NULL,NULL,NULL))
211 : : {
212 : 0 : fprintf(stderr,"EncryptInit failed\n");
213 : 0 : ERR_print_errors_fp(stderr);
214 : 0 : test1_exit(10);
215 : : }
216 [ - + ]: 1 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN, in, NULL))
217 : : {
218 : 0 : fprintf(stderr,"IV length set failed\n");
219 : 0 : ERR_print_errors_fp(stderr);
220 : 0 : test1_exit(11);
221 : : }
222 [ - + ]: 1 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG, tn, NULL))
223 : : {
224 : 0 : fprintf(stderr,"Tag length set failed\n");
225 : 0 : ERR_print_errors_fp(stderr);
226 : 0 : test1_exit(11);
227 : : }
228 [ - + ]: 1 : if(!EVP_EncryptInit_ex(ctx,NULL,NULL,key,iv))
229 : : {
230 : 0 : fprintf(stderr,"Key/IV set failed\n");
231 : 0 : ERR_print_errors_fp(stderr);
232 : 0 : test1_exit(12);
233 : : }
234 [ - + ]: 1 : if (!EVP_EncryptUpdate(ctx,NULL,&outl,NULL,pn))
235 : : {
236 : 0 : fprintf(stderr,"Plaintext length set failed\n");
237 : 0 : ERR_print_errors_fp(stderr);
238 : 0 : test1_exit(12);
239 : : }
240 [ + - ][ - + ]: 1 : if (an && !EVP_EncryptUpdate(ctx,NULL,&outl,aad,an))
241 : : {
242 : 0 : fprintf(stderr,"AAD set failed\n");
243 : 0 : ERR_print_errors_fp(stderr);
244 : 0 : test1_exit(13);
245 : : }
246 : : }
247 [ + + ]: 160 : else if (mode == EVP_CIPH_WRAP_MODE)
248 : : {
249 [ - + ][ - + ]: 8 : if(!EVP_EncryptInit_ex(ctx,c,NULL,key,in ? iv : NULL))
250 : : {
251 : 0 : fprintf(stderr,"EncryptInit failed\n");
252 : 0 : ERR_print_errors_fp(stderr);
253 : 0 : test1_exit(10);
254 : : }
255 : : }
256 [ - + ]: 152 : else if(!EVP_EncryptInit_ex(ctx,c,NULL,key,iv))
257 : : {
258 : 0 : fprintf(stderr,"EncryptInit failed\n");
259 : 0 : ERR_print_errors_fp(stderr);
260 : 0 : test1_exit(10);
261 : : }
262 : 186 : EVP_CIPHER_CTX_set_padding(ctx,0);
263 : :
264 : 186 : test_ctx_replace(&ctx);
265 : :
266 [ - + ]: 186 : if(!EVP_EncryptUpdate(ctx,out,&outl,plaintext,pn))
267 : : {
268 : 0 : fprintf(stderr,"Encrypt failed\n");
269 : 0 : ERR_print_errors_fp(stderr);
270 : 0 : test1_exit(6);
271 : : }
272 [ - + ]: 186 : if(!EVP_EncryptFinal_ex(ctx,out+outl,&outl2))
273 : : {
274 : 0 : fprintf(stderr,"EncryptFinal failed\n");
275 : 0 : ERR_print_errors_fp(stderr);
276 : 0 : test1_exit(7);
277 : : }
278 : :
279 [ - + ]: 186 : if(outl+outl2 != cn)
280 : : {
281 : 0 : fprintf(stderr,"Ciphertext length mismatch got %d expected %d\n",
282 : : outl+outl2,cn);
283 : 0 : test1_exit(8);
284 : : }
285 : :
286 [ - + ]: 186 : if(memcmp(out,ciphertext,cn))
287 : : {
288 : 0 : fprintf(stderr,"Ciphertext mismatch\n");
289 : 0 : hexdump(stderr,"Got",out,cn);
290 : 0 : hexdump(stderr,"Expected",ciphertext,cn);
291 : 0 : test1_exit(9);
292 : : }
293 [ + + ]: 186 : if (mode == EVP_CIPH_GCM_MODE || mode == EVP_CIPH_CCM_MODE)
294 : : {
295 : : unsigned char rtag[16];
296 : : /* Note: EVP_CTRL_CCM_GET_TAG has same value as
297 : : * EVP_CTRL_GCM_GET_TAG
298 : : */
299 [ - + ]: 26 : if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, tn, rtag))
300 : : {
301 : 0 : fprintf(stderr,"Get tag failed\n");
302 : 0 : ERR_print_errors_fp(stderr);
303 : 0 : test1_exit(14);
304 : : }
305 [ - + ]: 26 : if (memcmp(rtag, tag, tn))
306 : : {
307 : 0 : fprintf(stderr,"Tag mismatch\n");
308 : 0 : hexdump(stderr,"Got",rtag,tn);
309 : 0 : hexdump(stderr,"Expected",tag,tn);
310 : 26 : test1_exit(9);
311 : : }
312 : : }
313 : : }
314 : :
315 [ + + ]: 238 : if (encdec <= 0)
316 : : {
317 [ + + ]: 171 : if (mode == EVP_CIPH_GCM_MODE)
318 : : {
319 [ - + ]: 25 : if(!EVP_DecryptInit_ex(ctx,c,NULL,NULL,NULL))
320 : : {
321 : 0 : fprintf(stderr,"EncryptInit failed\n");
322 : 0 : ERR_print_errors_fp(stderr);
323 : 0 : test1_exit(10);
324 : : }
325 [ - + ]: 25 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, in, NULL))
326 : : {
327 : 0 : fprintf(stderr,"IV length set failed\n");
328 : 0 : ERR_print_errors_fp(stderr);
329 : 0 : test1_exit(11);
330 : : }
331 [ - + ]: 25 : if(!EVP_DecryptInit_ex(ctx,NULL,NULL,key,iv))
332 : : {
333 : 0 : fprintf(stderr,"Key/IV set failed\n");
334 : 0 : ERR_print_errors_fp(stderr);
335 : 0 : test1_exit(12);
336 : : }
337 [ - + ]: 25 : if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, tn, (void *)tag))
338 : : {
339 : 0 : fprintf(stderr,"Set tag failed\n");
340 : 0 : ERR_print_errors_fp(stderr);
341 : 0 : test1_exit(14);
342 : : }
343 [ + + ][ - + ]: 25 : if (an && !EVP_DecryptUpdate(ctx,NULL,&outl,aad,an))
344 : : {
345 : 0 : fprintf(stderr,"AAD set failed\n");
346 : 0 : ERR_print_errors_fp(stderr);
347 : 0 : test1_exit(13);
348 : : }
349 : : }
350 [ + + ]: 146 : else if (mode == EVP_CIPH_CCM_MODE)
351 : : {
352 [ - + ]: 1 : if(!EVP_DecryptInit_ex(ctx,c,NULL,NULL,NULL))
353 : : {
354 : 0 : fprintf(stderr,"DecryptInit failed\n");
355 : 0 : ERR_print_errors_fp(stderr);
356 : 0 : test1_exit(10);
357 : : }
358 [ - + ]: 1 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN, in, NULL))
359 : : {
360 : 0 : fprintf(stderr,"IV length set failed\n");
361 : 0 : ERR_print_errors_fp(stderr);
362 : 0 : test1_exit(11);
363 : : }
364 [ - + ]: 1 : if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG, tn, (void *)tag))
365 : : {
366 : 0 : fprintf(stderr,"Tag length set failed\n");
367 : 0 : ERR_print_errors_fp(stderr);
368 : 0 : test1_exit(11);
369 : : }
370 [ - + ]: 1 : if(!EVP_DecryptInit_ex(ctx,NULL,NULL,key,iv))
371 : : {
372 : 0 : fprintf(stderr,"Key/Nonce set failed\n");
373 : 0 : ERR_print_errors_fp(stderr);
374 : 0 : test1_exit(12);
375 : : }
376 [ - + ]: 1 : if (!EVP_DecryptUpdate(ctx,NULL,&outl,NULL,pn))
377 : : {
378 : 0 : fprintf(stderr,"Plaintext length set failed\n");
379 : 0 : ERR_print_errors_fp(stderr);
380 : 0 : test1_exit(12);
381 : : }
382 [ + - ][ - + ]: 1 : if (an && !EVP_EncryptUpdate(ctx,NULL,&outl,aad,an))
383 : : {
384 : 0 : fprintf(stderr,"AAD set failed\n");
385 : 0 : ERR_print_errors_fp(stderr);
386 : 0 : test1_exit(13);
387 : : }
388 : : }
389 [ + + ]: 145 : else if (mode == EVP_CIPH_WRAP_MODE)
390 : : {
391 [ - + ][ - + ]: 8 : if(!EVP_DecryptInit_ex(ctx,c,NULL,key,in ? iv : NULL))
392 : : {
393 : 0 : fprintf(stderr,"EncryptInit failed\n");
394 : 0 : ERR_print_errors_fp(stderr);
395 : 0 : test1_exit(10);
396 : : }
397 : : }
398 [ - + ]: 137 : else if(!EVP_DecryptInit_ex(ctx,c,NULL,key,iv))
399 : : {
400 : 0 : fprintf(stderr,"DecryptInit failed\n");
401 : 0 : ERR_print_errors_fp(stderr);
402 : 0 : test1_exit(11);
403 : : }
404 : 171 : EVP_CIPHER_CTX_set_padding(ctx,0);
405 : :
406 : 171 : test_ctx_replace(&ctx);
407 : :
408 [ - + ]: 171 : if(!EVP_DecryptUpdate(ctx,out,&outl,ciphertext,cn))
409 : : {
410 : 0 : fprintf(stderr,"Decrypt failed\n");
411 : 0 : ERR_print_errors_fp(stderr);
412 : 0 : test1_exit(6);
413 : : }
414 [ + + ][ - + ]: 171 : if(mode != EVP_CIPH_CCM_MODE && !EVP_DecryptFinal_ex(ctx,out+outl,&outl2))
415 : : {
416 : 0 : fprintf(stderr,"DecryptFinal failed\n");
417 : 0 : ERR_print_errors_fp(stderr);
418 : 0 : test1_exit(7);
419 : : }
420 : :
421 [ - + ]: 171 : if(outl+outl2 != pn)
422 : : {
423 : 0 : fprintf(stderr,"Plaintext length mismatch got %d expected %d\n",
424 : : outl+outl2,pn);
425 : 0 : test1_exit(8);
426 : : }
427 : :
428 [ - + ]: 171 : if(memcmp(out,plaintext,pn))
429 : : {
430 : 0 : fprintf(stderr,"Plaintext mismatch\n");
431 : 0 : hexdump(stderr,"Got",out,pn);
432 : 0 : hexdump(stderr,"Expected",plaintext,pn);
433 : 0 : test1_exit(9);
434 : : }
435 : : }
436 : :
437 : 238 : EVP_CIPHER_CTX_free(ctx);
438 : :
439 : : printf("\n");
440 : 238 : }
441 : :
442 : 246 : static int test_cipher(const char *cipher,const unsigned char *key,int kn,
443 : : const unsigned char *iv,int in,
444 : : const unsigned char *plaintext,int pn,
445 : : const unsigned char *ciphertext,int cn,
446 : : const unsigned char *aad,int an,
447 : : const unsigned char *tag,int tn,
448 : : int encdec)
449 : : {
450 : : const EVP_CIPHER *c;
451 : :
452 : 246 : c=EVP_get_cipherbyname(cipher);
453 [ + + ]: 246 : if(!c)
454 : : return 0;
455 : :
456 : 238 : test1(c,key,kn,iv,in,plaintext,pn,ciphertext,cn,aad,an,tag,tn,encdec);
457 : :
458 : 238 : return 1;
459 : : }
460 : :
461 : 8 : static int test_digest(const char *digest,
462 : : const unsigned char *plaintext,int pn,
463 : : const unsigned char *ciphertext, unsigned int cn)
464 : : {
465 : : const EVP_MD *d;
466 : : EVP_MD_CTX ctx;
467 : : unsigned char md[EVP_MAX_MD_SIZE];
468 : : unsigned int mdn;
469 : :
470 : 8 : d=EVP_get_digestbyname(digest);
471 [ + - ]: 8 : if(!d)
472 : : return 0;
473 : :
474 : 8 : printf("Testing digest %s\n",EVP_MD_name(d));
475 : 8 : hexdump(stdout,"Plaintext",plaintext,pn);
476 : 8 : hexdump(stdout,"Digest",ciphertext,cn);
477 : :
478 : 8 : EVP_MD_CTX_init(&ctx);
479 [ - + ]: 8 : if(!EVP_DigestInit_ex(&ctx,d, NULL))
480 : : {
481 : 0 : fprintf(stderr,"DigestInit failed\n");
482 : 0 : ERR_print_errors_fp(stderr);
483 : 0 : EXIT(100);
484 : : }
485 [ - + ]: 8 : if(!EVP_DigestUpdate(&ctx,plaintext,pn))
486 : : {
487 : 0 : fprintf(stderr,"DigestUpdate failed\n");
488 : 0 : ERR_print_errors_fp(stderr);
489 : 0 : EXIT(101);
490 : : }
491 [ - + ]: 8 : if(!EVP_DigestFinal_ex(&ctx,md,&mdn))
492 : : {
493 : 0 : fprintf(stderr,"DigestFinal failed\n");
494 : 0 : ERR_print_errors_fp(stderr);
495 : 0 : EXIT(101);
496 : : }
497 : 8 : EVP_MD_CTX_cleanup(&ctx);
498 : :
499 [ - + ]: 8 : if(mdn != cn)
500 : : {
501 : 0 : fprintf(stderr,"Digest length mismatch, got %d expected %d\n",mdn,cn);
502 : 0 : EXIT(102);
503 : : }
504 : :
505 [ - + ]: 8 : if(memcmp(md,ciphertext,cn))
506 : : {
507 : 0 : fprintf(stderr,"Digest mismatch\n");
508 : 0 : hexdump(stderr,"Got",md,cn);
509 : 0 : hexdump(stderr,"Expected",ciphertext,cn);
510 : 0 : EXIT(103);
511 : : }
512 : :
513 : : printf("\n");
514 : :
515 : 8 : EVP_MD_CTX_cleanup(&ctx);
516 : :
517 : 8 : return 1;
518 : : }
519 : :
520 : 1 : int main(int argc,char **argv)
521 : : {
522 : : const char *szTestFile;
523 : : FILE *f;
524 : :
525 [ - + ]: 1 : if(argc != 2)
526 : : {
527 : 0 : fprintf(stderr,"%s <test file>\n",argv[0]);
528 : 0 : EXIT(1);
529 : : }
530 : 1 : CRYPTO_malloc_debug_init();
531 : 1 : CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
532 : 1 : CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
533 : :
534 : 1 : szTestFile=argv[1];
535 : :
536 : 1 : f=fopen(szTestFile,"r");
537 [ - + ]: 1 : if(!f)
538 : : {
539 : 0 : perror(szTestFile);
540 : 0 : EXIT(2);
541 : : }
542 : 1 : ERR_load_crypto_strings();
543 : : /* Load up the software EVP_CIPHER and EVP_MD definitions */
544 : 1 : OpenSSL_add_all_ciphers();
545 : 1 : OpenSSL_add_all_digests();
546 : : #ifndef OPENSSL_NO_ENGINE
547 : : /* Load all compiled-in ENGINEs */
548 : 1 : ENGINE_load_builtin_engines();
549 : : #endif
550 : : #if 0
551 : : OPENSSL_config();
552 : : #endif
553 : : #ifndef OPENSSL_NO_ENGINE
554 : : /* Register all available ENGINE implementations of ciphers and digests.
555 : : * This could perhaps be changed to "ENGINE_register_all_complete()"? */
556 : 1 : ENGINE_register_all_ciphers();
557 : 408 : ENGINE_register_all_digests();
558 : : /* If we add command-line options, this statement should be switchable.
559 : : * It'll prevent ENGINEs being ENGINE_init()ialised for cipher/digest use if
560 : : * they weren't already initialised. */
561 : : /* ENGINE_set_cipher_flags(ENGINE_CIPHER_FLAG_NOINIT); */
562 : : #endif
563 : :
564 : : for( ; ; )
565 : : {
566 : : char line[4096];
567 : : char *p;
568 : : char *cipher;
569 : : unsigned char *iv,*key,*plaintext,*ciphertext,*aad,*tag;
570 : : int encdec;
571 : : int kn,in,pn,cn;
572 : 408 : int an = 0;
573 : 408 : int tn = 0;
574 : :
575 [ + + ]: 408 : if(!fgets((char *)line,sizeof line,f))
576 : : break;
577 [ + + ]: 407 : if(line[0] == '#' || line[0] == '\n')
578 : 161 : continue;
579 : 246 : p=line;
580 : 246 : cipher=sstrsep(&p,":");
581 : 246 : key=ustrsep(&p,":");
582 : 246 : iv=ustrsep(&p,":");
583 : 246 : plaintext=ustrsep(&p,":");
584 : 246 : ciphertext=ustrsep(&p,":");
585 [ + + ]: 246 : if (p[-1] == '\n') {
586 : 101 : encdec = -1;
587 : 101 : p[-1] = '\0';
588 : 101 : tag=aad=NULL;
589 : 101 : an=tn=0;
590 : : } else {
591 : 145 : aad=ustrsep(&p,":");
592 : 145 : tag=ustrsep(&p,":");
593 [ + + ]: 145 : if (tag == NULL) {
594 : 119 : p = (char *)aad;
595 : 119 : tag=aad=NULL;
596 : 119 : an=tn=0;
597 : : }
598 [ + + ]: 145 : if (p [-1] == '\n') {
599 : 26 : encdec = -1;
600 : 26 : p[-1] = '\0';
601 : : } else
602 : 119 : encdec = atoi(sstrsep(&p,"\n"));
603 : : }
604 : :
605 : 246 : kn=convert(key);
606 : 246 : in=convert(iv);
607 : 246 : pn=convert(plaintext);
608 : 246 : cn=convert(ciphertext);
609 [ + + ]: 246 : if (aad) {
610 : 26 : an=convert(aad);
611 : 26 : tn=convert(tag);
612 : : }
613 : :
614 [ + + ]: 246 : if(!test_cipher(cipher,key,kn,iv,in,plaintext,pn,ciphertext,cn,aad,an,tag,tn,encdec)
615 [ - + ]: 8 : && !test_digest(cipher,plaintext,pn,ciphertext,cn))
616 : : {
617 : : #ifdef OPENSSL_NO_AES
618 : : if (strstr(cipher, "AES") == cipher)
619 : : {
620 : : fprintf(stdout, "Cipher disabled, skipping %s\n", cipher);
621 : : continue;
622 : : }
623 : : #endif
624 : : #ifdef OPENSSL_NO_DES
625 : : if (strstr(cipher, "DES") == cipher)
626 : : {
627 : : fprintf(stdout, "Cipher disabled, skipping %s\n", cipher);
628 : : continue;
629 : : }
630 : : #endif
631 : : #ifdef OPENSSL_NO_RC4
632 : : if (strstr(cipher, "RC4") == cipher)
633 : : {
634 : : fprintf(stdout, "Cipher disabled, skipping %s\n", cipher);
635 : : continue;
636 : : }
637 : : #endif
638 : : #ifdef OPENSSL_NO_CAMELLIA
639 : : if (strstr(cipher, "CAMELLIA") == cipher)
640 : : {
641 : : fprintf(stdout, "Cipher disabled, skipping %s\n", cipher);
642 : : continue;
643 : : }
644 : : #endif
645 : : #ifdef OPENSSL_NO_SEED
646 : : if (strstr(cipher, "SEED") == cipher)
647 : : {
648 : : fprintf(stdout, "Cipher disabled, skipping %s\n", cipher);
649 : : continue;
650 : : }
651 : : #endif
652 : 0 : fprintf(stderr,"Can't find %s\n",cipher);
653 : 246 : EXIT(3);
654 : : }
655 : : }
656 : 1 : fclose(f);
657 : :
658 : : #ifndef OPENSSL_NO_ENGINE
659 : 1 : ENGINE_cleanup();
660 : : #endif
661 : 1 : EVP_cleanup();
662 : 1 : CRYPTO_cleanup_all_ex_data();
663 : 1 : ERR_remove_thread_state(NULL);
664 : 1 : ERR_free_strings();
665 : 1 : CRYPTO_mem_leaks_fp(stderr);
666 : :
667 : 1 : return 0;
668 : : }
|
