]> git.ipfire.org Git - thirdparty/openssl.git/blob - fips/aes/fips_aesavs.c
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add support for multicall fips_algvs utility combining functionality
[thirdparty/openssl.git] / fips / aes / fips_aesavs.c
1 /* ====================================================================
2 * Copyright (c) 2004 The OpenSSL Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. All advertising materials mentioning features or use of this
17 * software must display the following acknowledgment:
18 * "This product includes software developed by the OpenSSL Project
19 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
20 *
21 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22 * endorse or promote products derived from this software without
23 * prior written permission. For written permission, please contact
24 * openssl-core@openssl.org.
25 *
26 * 5. Products derived from this software may not be called "OpenSSL"
27 * nor may "OpenSSL" appear in their names without prior written
28 * permission of the OpenSSL Project.
29 *
30 * 6. Redistributions of any form whatsoever must retain the following
31 * acknowledgment:
32 * "This product includes software developed by the OpenSSL Project
33 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46 * OF THE POSSIBILITY OF SUCH DAMAGE.
47 *
48 */
49 /*---------------------------------------------
50 NIST AES Algorithm Validation Suite
51 Test Program
52
53 Donated to OpenSSL by:
54 V-ONE Corporation
55 20250 Century Blvd, Suite 300
56 Germantown, MD 20874
57 U.S.A.
58 ----------------------------------------------*/
59
60 #define OPENSSL_FIPSAPI
61
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <errno.h>
66 #include <assert.h>
67 #include <ctype.h>
68 #include <openssl/aes.h>
69 #include <openssl/evp.h>
70 #include <openssl/bn.h>
71
72 #include <openssl/err.h>
73 #include "e_os.h"
74
75 #ifndef OPENSSL_FIPS
76
77 int main(int argc, char *argv[])
78 {
79 printf("No FIPS AES support\n");
80 return(0);
81 }
82
83 #else
84
85 #include <openssl/fips.h>
86 #include "fips_utl.h"
87
88 #define AES_BLOCK_SIZE 16
89
90 #define VERBOSE 0
91
92 /*-----------------------------------------------*/
93
94 static int AESTest(EVP_CIPHER_CTX *ctx,
95 char *amode, int akeysz, unsigned char *aKey,
96 unsigned char *iVec,
97 int dir, /* 0 = decrypt, 1 = encrypt */
98 unsigned char *plaintext, unsigned char *ciphertext, int len)
99 {
100 const EVP_CIPHER *cipher = NULL;
101
102 if (strcasecmp(amode, "CBC") == 0)
103 {
104 switch (akeysz)
105 {
106 case 128:
107 cipher = EVP_aes_128_cbc();
108 break;
109
110 case 192:
111 cipher = EVP_aes_192_cbc();
112 break;
113
114 case 256:
115 cipher = EVP_aes_256_cbc();
116 break;
117 }
118
119 }
120 else if (strcasecmp(amode, "ECB") == 0)
121 {
122 switch (akeysz)
123 {
124 case 128:
125 cipher = EVP_aes_128_ecb();
126 break;
127
128 case 192:
129 cipher = EVP_aes_192_ecb();
130 break;
131
132 case 256:
133 cipher = EVP_aes_256_ecb();
134 break;
135 }
136 }
137 else if (strcasecmp(amode, "CFB128") == 0)
138 {
139 switch (akeysz)
140 {
141 case 128:
142 cipher = EVP_aes_128_cfb128();
143 break;
144
145 case 192:
146 cipher = EVP_aes_192_cfb128();
147 break;
148
149 case 256:
150 cipher = EVP_aes_256_cfb128();
151 break;
152 }
153
154 }
155 else if (fips_strncasecmp(amode, "OFB", 3) == 0)
156 {
157 switch (akeysz)
158 {
159 case 128:
160 cipher = EVP_aes_128_ofb();
161 break;
162
163 case 192:
164 cipher = EVP_aes_192_ofb();
165 break;
166
167 case 256:
168 cipher = EVP_aes_256_ofb();
169 break;
170 }
171 }
172 else if(!strcasecmp(amode,"CFB1"))
173 {
174 switch (akeysz)
175 {
176 case 128:
177 cipher = EVP_aes_128_cfb1();
178 break;
179
180 case 192:
181 cipher = EVP_aes_192_cfb1();
182 break;
183
184 case 256:
185 cipher = EVP_aes_256_cfb1();
186 break;
187 }
188 }
189 else if(!strcasecmp(amode,"CFB8"))
190 {
191 switch (akeysz)
192 {
193 case 128:
194 cipher = EVP_aes_128_cfb8();
195 break;
196
197 case 192:
198 cipher = EVP_aes_192_cfb8();
199 break;
200
201 case 256:
202 cipher = EVP_aes_256_cfb8();
203 break;
204 }
205 }
206 else
207 {
208 printf("Unknown mode: %s\n", amode);
209 return 0;
210 }
211 if (!cipher)
212 {
213 printf("Invalid key size: %d\n", akeysz);
214 return 0;
215 }
216 if (FIPS_cipherinit(ctx, cipher, aKey, iVec, dir) <= 0)
217 return 0;
218 if(!strcasecmp(amode,"CFB1"))
219 M_EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS);
220 if (dir)
221 FIPS_cipher(ctx, ciphertext, plaintext, len);
222 else
223 FIPS_cipher(ctx, plaintext, ciphertext, len);
224 return 1;
225 }
226
227 /*-----------------------------------------------*/
228 char *t_tag[2] = {"PLAINTEXT", "CIPHERTEXT"};
229 char *t_mode[6] = {"CBC","ECB","OFB","CFB1","CFB8","CFB128"};
230 enum Mode {CBC, ECB, OFB, CFB1, CFB8, CFB128};
231 enum XCrypt {XDECRYPT, XENCRYPT};
232
233 /*=============================*/
234 /* Monte Carlo Tests */
235 /*-----------------------------*/
236
237 /*#define gb(a,b) (((a)[(b)/8] >> ((b)%8))&1)*/
238 /*#define sb(a,b,v) ((a)[(b)/8]=((a)[(b)/8]&~(1 << ((b)%8)))|(!!(v) << ((b)%8)))*/
239
240 #define gb(a,b) (((a)[(b)/8] >> (7-(b)%8))&1)
241 #define sb(a,b,v) ((a)[(b)/8]=((a)[(b)/8]&~(1 << (7-(b)%8)))|(!!(v) << (7-(b)%8)))
242
243 static int do_mct(char *amode,
244 int akeysz, unsigned char *aKey,unsigned char *iVec,
245 int dir, unsigned char *text, int len,
246 FILE *rfp)
247 {
248 int ret = 0;
249 unsigned char key[101][32];
250 unsigned char iv[101][AES_BLOCK_SIZE];
251 unsigned char ptext[1001][32];
252 unsigned char ctext[1001][32];
253 unsigned char ciphertext[64+4];
254 int i, j, n, n1, n2;
255 int imode = 0, nkeysz = akeysz/8;
256 EVP_CIPHER_CTX ctx;
257 FIPS_cipher_ctx_init(&ctx);
258
259 if (len > 32)
260 {
261 printf("\n>>>> Length exceeds 32 for %s %d <<<<\n\n",
262 amode, akeysz);
263 return -1;
264 }
265 for (imode = 0; imode < 6; ++imode)
266 if (strcmp(amode, t_mode[imode]) == 0)
267 break;
268 if (imode == 6)
269 {
270 printf("Unrecognized mode: %s\n", amode);
271 return -1;
272 }
273
274 memcpy(key[0], aKey, nkeysz);
275 if (iVec)
276 memcpy(iv[0], iVec, AES_BLOCK_SIZE);
277 if (dir == XENCRYPT)
278 memcpy(ptext[0], text, len);
279 else
280 memcpy(ctext[0], text, len);
281 for (i = 0; i < 100; ++i)
282 {
283 /* printf("Iteration %d\n", i); */
284 if (i > 0)
285 {
286 fprintf(rfp,"COUNT = %d" RESP_EOL ,i);
287 OutputValue("KEY",key[i],nkeysz,rfp,0);
288 if (imode != ECB) /* ECB */
289 OutputValue("IV",iv[i],AES_BLOCK_SIZE,rfp,0);
290 /* Output Ciphertext | Plaintext */
291 OutputValue(t_tag[dir^1],dir ? ptext[0] : ctext[0],len,rfp,
292 imode == CFB1);
293 }
294 for (j = 0; j < 1000; ++j)
295 {
296 switch (imode)
297 {
298 case ECB:
299 if (j == 0)
300 { /* set up encryption */
301 ret = AESTest(&ctx, amode, akeysz, key[i], NULL,
302 dir, /* 0 = decrypt, 1 = encrypt */
303 ptext[j], ctext[j], len);
304 if (dir == XENCRYPT)
305 memcpy(ptext[j+1], ctext[j], len);
306 else
307 memcpy(ctext[j+1], ptext[j], len);
308 }
309 else
310 {
311 if (dir == XENCRYPT)
312 {
313 FIPS_cipher(&ctx, ctext[j], ptext[j], len);
314 memcpy(ptext[j+1], ctext[j], len);
315 }
316 else
317 {
318 FIPS_cipher(&ctx, ptext[j], ctext[j], len);
319 memcpy(ctext[j+1], ptext[j], len);
320 }
321 }
322 break;
323
324 case CBC:
325 case OFB:
326 case CFB128:
327 if (j == 0)
328 {
329 ret = AESTest(&ctx, amode, akeysz, key[i], iv[i],
330 dir, /* 0 = decrypt, 1 = encrypt */
331 ptext[j], ctext[j], len);
332 if (dir == XENCRYPT)
333 memcpy(ptext[j+1], iv[i], len);
334 else
335 memcpy(ctext[j+1], iv[i], len);
336 }
337 else
338 {
339 if (dir == XENCRYPT)
340 {
341 FIPS_cipher(&ctx, ctext[j], ptext[j], len);
342 memcpy(ptext[j+1], ctext[j-1], len);
343 }
344 else
345 {
346 FIPS_cipher(&ctx, ptext[j], ctext[j], len);
347 memcpy(ctext[j+1], ptext[j-1], len);
348 }
349 }
350 break;
351
352 case CFB8:
353 if (j == 0)
354 {
355 ret = AESTest(&ctx, amode, akeysz, key[i], iv[i],
356 dir, /* 0 = decrypt, 1 = encrypt */
357 ptext[j], ctext[j], len);
358 }
359 else
360 {
361 if (dir == XENCRYPT)
362 FIPS_cipher(&ctx, ctext[j], ptext[j], len);
363 else
364 FIPS_cipher(&ctx, ptext[j], ctext[j], len);
365 }
366 if (dir == XENCRYPT)
367 {
368 if (j < 16)
369 memcpy(ptext[j+1], &iv[i][j], len);
370 else
371 memcpy(ptext[j+1], ctext[j-16], len);
372 }
373 else
374 {
375 if (j < 16)
376 memcpy(ctext[j+1], &iv[i][j], len);
377 else
378 memcpy(ctext[j+1], ptext[j-16], len);
379 }
380 break;
381
382 case CFB1:
383 if(j == 0)
384 {
385 #if 0
386 /* compensate for wrong endianness of input file */
387 if(i == 0)
388 ptext[0][0]<<=7;
389 #endif
390 ret = AESTest(&ctx,amode,akeysz,key[i],iv[i],dir,
391 ptext[j], ctext[j], len);
392 }
393 else
394 {
395 if (dir == XENCRYPT)
396 FIPS_cipher(&ctx, ctext[j], ptext[j], len);
397 else
398 FIPS_cipher(&ctx, ptext[j], ctext[j], len);
399
400 }
401 if(dir == XENCRYPT)
402 {
403 if(j < 128)
404 sb(ptext[j+1],0,gb(iv[i],j));
405 else
406 sb(ptext[j+1],0,gb(ctext[j-128],0));
407 }
408 else
409 {
410 if(j < 128)
411 sb(ctext[j+1],0,gb(iv[i],j));
412 else
413 sb(ctext[j+1],0,gb(ptext[j-128],0));
414 }
415 break;
416 }
417 }
418 --j; /* reset to last of range */
419 /* Output Ciphertext | Plaintext */
420 OutputValue(t_tag[dir],dir ? ctext[j] : ptext[j],len,rfp,
421 imode == CFB1);
422 fprintf(rfp, RESP_EOL); /* add separator */
423
424 /* Compute next KEY */
425 if (dir == XENCRYPT)
426 {
427 if (imode == CFB8)
428 { /* ct = CT[j-15] || CT[j-14] || ... || CT[j] */
429 for (n1 = 0, n2 = nkeysz-1; n1 < nkeysz; ++n1, --n2)
430 ciphertext[n1] = ctext[j-n2][0];
431 }
432 else if(imode == CFB1)
433 {
434 for(n1=0,n2=akeysz-1 ; n1 < akeysz ; ++n1,--n2)
435 sb(ciphertext,n1,gb(ctext[j-n2],0));
436 }
437 else
438 switch (akeysz)
439 {
440 case 128:
441 memcpy(ciphertext, ctext[j], 16);
442 break;
443 case 192:
444 memcpy(ciphertext, ctext[j-1]+8, 8);
445 memcpy(ciphertext+8, ctext[j], 16);
446 break;
447 case 256:
448 memcpy(ciphertext, ctext[j-1], 16);
449 memcpy(ciphertext+16, ctext[j], 16);
450 break;
451 }
452 }
453 else
454 {
455 if (imode == CFB8)
456 { /* ct = CT[j-15] || CT[j-14] || ... || CT[j] */
457 for (n1 = 0, n2 = nkeysz-1; n1 < nkeysz; ++n1, --n2)
458 ciphertext[n1] = ptext[j-n2][0];
459 }
460 else if(imode == CFB1)
461 {
462 for(n1=0,n2=akeysz-1 ; n1 < akeysz ; ++n1,--n2)
463 sb(ciphertext,n1,gb(ptext[j-n2],0));
464 }
465 else
466 switch (akeysz)
467 {
468 case 128:
469 memcpy(ciphertext, ptext[j], 16);
470 break;
471 case 192:
472 memcpy(ciphertext, ptext[j-1]+8, 8);
473 memcpy(ciphertext+8, ptext[j], 16);
474 break;
475 case 256:
476 memcpy(ciphertext, ptext[j-1], 16);
477 memcpy(ciphertext+16, ptext[j], 16);
478 break;
479 }
480 }
481 /* Compute next key: Key[i+1] = Key[i] xor ct */
482 for (n = 0; n < nkeysz; ++n)
483 key[i+1][n] = key[i][n] ^ ciphertext[n];
484
485 /* Compute next IV and text */
486 if (dir == XENCRYPT)
487 {
488 switch (imode)
489 {
490 case ECB:
491 memcpy(ptext[0], ctext[j], AES_BLOCK_SIZE);
492 break;
493 case CBC:
494 case OFB:
495 case CFB128:
496 memcpy(iv[i+1], ctext[j], AES_BLOCK_SIZE);
497 memcpy(ptext[0], ctext[j-1], AES_BLOCK_SIZE);
498 break;
499 case CFB8:
500 /* IV[i+1] = ct */
501 for (n1 = 0, n2 = 15; n1 < 16; ++n1, --n2)
502 iv[i+1][n1] = ctext[j-n2][0];
503 ptext[0][0] = ctext[j-16][0];
504 break;
505 case CFB1:
506 for(n1=0,n2=127 ; n1 < 128 ; ++n1,--n2)
507 sb(iv[i+1],n1,gb(ctext[j-n2],0));
508 ptext[0][0]=ctext[j-128][0]&0x80;
509 break;
510 }
511 }
512 else
513 {
514 switch (imode)
515 {
516 case ECB:
517 memcpy(ctext[0], ptext[j], AES_BLOCK_SIZE);
518 break;
519 case CBC:
520 case OFB:
521 case CFB128:
522 memcpy(iv[i+1], ptext[j], AES_BLOCK_SIZE);
523 memcpy(ctext[0], ptext[j-1], AES_BLOCK_SIZE);
524 break;
525 case CFB8:
526 for (n1 = 0, n2 = 15; n1 < 16; ++n1, --n2)
527 iv[i+1][n1] = ptext[j-n2][0];
528 ctext[0][0] = ptext[j-16][0];
529 break;
530 case CFB1:
531 for(n1=0,n2=127 ; n1 < 128 ; ++n1,--n2)
532 sb(iv[i+1],n1,gb(ptext[j-n2],0));
533 ctext[0][0]=ptext[j-128][0]&0x80;
534 break;
535 }
536 }
537 }
538
539 return ret;
540 }
541
542 /*================================================*/
543 /*----------------------------
544 # Config info for v-one
545 # AESVS MMT test data for ECB
546 # State : Encrypt and Decrypt
547 # Key Length : 256
548 # Fri Aug 30 04:07:22 PM
549 ----------------------------*/
550
551 static int proc_file(char *rqfile, char *rspfile)
552 {
553 char afn[256], rfn[256];
554 FILE *afp = NULL, *rfp = NULL;
555 char ibuf[2048];
556 char tbuf[2048];
557 int ilen, len, ret = 0;
558 char algo[8] = "";
559 char amode[8] = "";
560 char atest[8] = "";
561 int akeysz = 0;
562 unsigned char iVec[20], aKey[40];
563 int dir = -1, err = 0, step = 0;
564 unsigned char plaintext[2048];
565 unsigned char ciphertext[2048];
566 char *rp;
567 EVP_CIPHER_CTX ctx;
568 FIPS_cipher_ctx_init(&ctx);
569
570 if (!rqfile || !(*rqfile))
571 {
572 printf("No req file\n");
573 return -1;
574 }
575 strcpy(afn, rqfile);
576
577 if ((afp = fopen(afn, "r")) == NULL)
578 {
579 printf("Cannot open file: %s, %s\n",
580 afn, strerror(errno));
581 return -1;
582 }
583 if (!rspfile)
584 {
585 strcpy(rfn,afn);
586 rp=strstr(rfn,"req/");
587 #ifdef OPENSSL_SYS_WIN32
588 if (!rp)
589 rp=strstr(rfn,"req\\");
590 #endif
591 assert(rp);
592 memcpy(rp,"rsp",3);
593 rp = strstr(rfn, ".req");
594 memcpy(rp, ".rsp", 4);
595 rspfile = rfn;
596 }
597 if ((rfp = fopen(rspfile, "w")) == NULL)
598 {
599 printf("Cannot open file: %s, %s\n",
600 rfn, strerror(errno));
601 fclose(afp);
602 afp = NULL;
603 return -1;
604 }
605 while (!err && (fgets(ibuf, sizeof(ibuf), afp)) != NULL)
606 {
607 tidy_line(tbuf, ibuf);
608 ilen = strlen(ibuf);
609 /* printf("step=%d ibuf=%s",step,ibuf); */
610 switch (step)
611 {
612 case 0: /* read preamble */
613 if (ibuf[0] == '\n')
614 { /* end of preamble */
615 if ((*algo == '\0') ||
616 (*amode == '\0') ||
617 (akeysz == 0))
618 {
619 printf("Missing Algorithm, Mode or KeySize (%s/%s/%d)\n",
620 algo,amode,akeysz);
621 err = 1;
622 }
623 else
624 {
625 copy_line(ibuf, rfp);
626 ++ step;
627 }
628 }
629 else if (ibuf[0] != '#')
630 {
631 printf("Invalid preamble item: %s\n", ibuf);
632 err = 1;
633 }
634 else
635 { /* process preamble */
636 char *xp, *pp = ibuf+2;
637 int n;
638 if (akeysz)
639 { /* insert current time & date */
640 time_t rtim = time(0);
641 fputs("# ", rfp);
642 copy_line(ctime(&rtim), rfp);
643 }
644 else
645 {
646 copy_line(ibuf, rfp);
647 if (strncmp(pp, "AESVS ", 6) == 0)
648 {
649 strcpy(algo, "AES");
650 /* get test type */
651 pp += 6;
652 xp = strchr(pp, ' ');
653 n = xp-pp;
654 strncpy(atest, pp, n);
655 atest[n] = '\0';
656 /* get mode */
657 xp = strrchr(pp, ' '); /* get mode" */
658 n = strlen(xp+1)-1;
659 strncpy(amode, xp+1, n);
660 amode[n] = '\0';
661 /* amode[3] = '\0'; */
662 if (VERBOSE)
663 printf("Test = %s, Mode = %s\n", atest, amode);
664 }
665 else if (fips_strncasecmp(pp, "Key Length : ", 13) == 0)
666 {
667 akeysz = atoi(pp+13);
668 if (VERBOSE)
669 printf("Key size = %d\n", akeysz);
670 }
671 }
672 }
673 break;
674
675 case 1: /* [ENCRYPT] | [DECRYPT] */
676 if (ibuf[0] == '[')
677 {
678 copy_line(ibuf, rfp);
679 ++step;
680 if (fips_strncasecmp(ibuf, "[ENCRYPT]", 9) == 0)
681 dir = 1;
682 else if (fips_strncasecmp(ibuf, "[DECRYPT]", 9) == 0)
683 dir = 0;
684 else
685 {
686 printf("Invalid keyword: %s\n", ibuf);
687 err = 1;
688 }
689 break;
690 }
691 else if (dir == -1)
692 {
693 err = 1;
694 printf("Missing ENCRYPT/DECRYPT keyword\n");
695 break;
696 }
697 else
698 step = 2;
699
700 case 2: /* KEY = xxxx */
701 copy_line(ibuf, rfp);
702 if(*ibuf == '\n')
703 break;
704 if(!fips_strncasecmp(ibuf,"COUNT = ",8))
705 break;
706
707 if (fips_strncasecmp(ibuf, "KEY = ", 6) != 0)
708 {
709 printf("Missing KEY\n");
710 err = 1;
711 }
712 else
713 {
714 len = hex2bin((char*)ibuf+6, aKey);
715 if (len < 0)
716 {
717 printf("Invalid KEY\n");
718 err =1;
719 break;
720 }
721 PrintValue("KEY", aKey, len);
722 if (strcmp(amode, "ECB") == 0)
723 {
724 memset(iVec, 0, sizeof(iVec));
725 step = (dir)? 4: 5; /* no ivec for ECB */
726 }
727 else
728 ++step;
729 }
730 break;
731
732 case 3: /* IV = xxxx */
733 copy_line(ibuf, rfp);
734 if (fips_strncasecmp(ibuf, "IV = ", 5) != 0)
735 {
736 printf("Missing IV\n");
737 err = 1;
738 }
739 else
740 {
741 len = hex2bin((char*)ibuf+5, iVec);
742 if (len < 0)
743 {
744 printf("Invalid IV\n");
745 err =1;
746 break;
747 }
748 PrintValue("IV", iVec, len);
749 step = (dir)? 4: 5;
750 }
751 break;
752
753 case 4: /* PLAINTEXT = xxxx */
754 copy_line(ibuf, rfp);
755 if (fips_strncasecmp(ibuf, "PLAINTEXT = ", 12) != 0)
756 {
757 printf("Missing PLAINTEXT\n");
758 err = 1;
759 }
760 else
761 {
762 int nn = strlen(ibuf+12);
763 if(!strcmp(amode,"CFB1"))
764 len=bint2bin(ibuf+12,nn-1,plaintext);
765 else
766 len=hex2bin(ibuf+12, plaintext);
767 if (len < 0)
768 {
769 printf("Invalid PLAINTEXT: %s", ibuf+12);
770 err =1;
771 break;
772 }
773 if (len >= (int)sizeof(plaintext))
774 {
775 printf("Buffer overflow\n");
776 }
777 PrintValue("PLAINTEXT", (unsigned char*)plaintext, len);
778 if (strcmp(atest, "MCT") == 0) /* Monte Carlo Test */
779 {
780 if(do_mct(amode, akeysz, aKey, iVec,
781 dir, (unsigned char*)plaintext, len,
782 rfp) < 0)
783 err = 1;
784 }
785 else
786 {
787 ret = AESTest(&ctx, amode, akeysz, aKey, iVec,
788 dir, /* 0 = decrypt, 1 = encrypt */
789 plaintext, ciphertext, len);
790 OutputValue("CIPHERTEXT",ciphertext,len,rfp,
791 !strcmp(amode,"CFB1"));
792 }
793 step = 6;
794 }
795 break;
796
797 case 5: /* CIPHERTEXT = xxxx */
798 copy_line(ibuf, rfp);
799 if (fips_strncasecmp(ibuf, "CIPHERTEXT = ", 13) != 0)
800 {
801 printf("Missing KEY\n");
802 err = 1;
803 }
804 else
805 {
806 if(!strcmp(amode,"CFB1"))
807 len=bint2bin(ibuf+13,strlen(ibuf+13)-1,ciphertext);
808 else
809 len = hex2bin(ibuf+13,ciphertext);
810 if (len < 0)
811 {
812 printf("Invalid CIPHERTEXT\n");
813 err =1;
814 break;
815 }
816
817 PrintValue("CIPHERTEXT", ciphertext, len);
818 if (strcmp(atest, "MCT") == 0) /* Monte Carlo Test */
819 {
820 do_mct(amode, akeysz, aKey, iVec,
821 dir, ciphertext, len, rfp);
822 }
823 else
824 {
825 ret = AESTest(&ctx, amode, akeysz, aKey, iVec,
826 dir, /* 0 = decrypt, 1 = encrypt */
827 plaintext, ciphertext, len);
828 OutputValue("PLAINTEXT",(unsigned char *)plaintext,len,rfp,
829 !strcmp(amode,"CFB1"));
830 }
831 step = 6;
832 }
833 break;
834
835 case 6:
836 if (ibuf[0] != '\n')
837 {
838 err = 1;
839 printf("Missing terminator\n");
840 }
841 else if (strcmp(atest, "MCT") != 0)
842 { /* MCT already added terminating nl */
843 copy_line(ibuf, rfp);
844 }
845 step = 1;
846 break;
847 }
848 }
849 if (rfp)
850 fclose(rfp);
851 if (afp)
852 fclose(afp);
853 return err;
854 }
855
856 /*--------------------------------------------------
857 Processes either a single file or
858 a set of files whose names are passed in a file.
859 A single file is specified as:
860 aes_test -f xxx.req
861 A set of files is specified as:
862 aes_test -d xxxxx.xxx
863 The default is: -d req.txt
864 --------------------------------------------------*/
865 #ifdef FIPS_ALGVS
866 int fips_aesavs_main(int argc, char **argv)
867 #else
868 int main(int argc, char **argv)
869 #endif
870 {
871 char *rqlist = "req.txt", *rspfile = NULL;
872 FILE *fp = NULL;
873 char fn[250] = "", rfn[256] = "";
874 int f_opt = 0, d_opt = 1;
875 fips_algtest_init();
876
877 if (argc > 1)
878 {
879 if (strcasecmp(argv[1], "-d") == 0)
880 {
881 d_opt = 1;
882 }
883 else if (strcasecmp(argv[1], "-f") == 0)
884 {
885 f_opt = 1;
886 d_opt = 0;
887 }
888 else
889 {
890 printf("Invalid parameter: %s\n", argv[1]);
891 return 0;
892 }
893 if (argc < 3)
894 {
895 printf("Missing parameter\n");
896 return 0;
897 }
898 if (d_opt)
899 rqlist = argv[2];
900 else
901 {
902 strcpy(fn, argv[2]);
903 rspfile = argv[3];
904 }
905 }
906 if (d_opt)
907 { /* list of files (directory) */
908 if (!(fp = fopen(rqlist, "r")))
909 {
910 printf("Cannot open req list file\n");
911 return -1;
912 }
913 while (fgets(fn, sizeof(fn), fp))
914 {
915 strtok(fn, "\r\n");
916 strcpy(rfn, fn);
917 if (VERBOSE)
918 printf("Processing: %s\n", rfn);
919 if (proc_file(rfn, rspfile))
920 {
921 printf(">>> Processing failed for: %s <<<\n", rfn);
922 return 1;
923 }
924 }
925 fclose(fp);
926 }
927 else /* single file */
928 {
929 if (VERBOSE)
930 printf("Processing: %s\n", fn);
931 if (proc_file(fn, rspfile))
932 {
933 printf(">>> Processing failed for: %s <<<\n", fn);
934 }
935 }
936 return 0;
937 }
938
939 #endif
Mirror of https://github.com/openssl/openssl.git