Include TA in checks/callback with partial chains.
[openssl.git] / test / fips_algvs.c
1 /* test/fips_algvs.c */
2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project 2011
4  */
5 /* ====================================================================
6  * Copyright (c) 2011 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 <stdio.h>
60 #include <openssl/crypto.h>
61 #include <openssl/opensslconf.h>
62
63 #ifndef OPENSSL_FIPS
64 #include <stdio.h>
65
66 int main(int argc, char **argv)
67 {
68     printf("No FIPS ALGVS support\n");
69     return 0;
70 }
71 #else
72
73 #define FIPS_ALGVS
74
75 extern int fips_aesavs_main(int argc, char **argv);
76 extern int fips_cmactest_main(int argc, char **argv);
77 extern int fips_desmovs_main(int argc, char **argv);
78 extern int fips_dhvs_main(int argc, char **argv);
79 extern int fips_drbgvs_main(int argc,char **argv);
80 extern int fips_dssvs_main(int argc, char **argv);
81 extern int fips_ecdhvs_main(int argc, char **argv);
82 extern int fips_ecdsavs_main(int argc, char **argv);
83 extern int fips_gcmtest_main(int argc, char **argv);
84 extern int fips_hmactest_main(int argc, char **argv);
85 extern int fips_rngvs_main(int argc, char **argv);
86 extern int fips_rsagtest_main(int argc, char **argv);
87 extern int fips_rsastest_main(int argc, char **argv);
88 extern int fips_rsavtest_main(int argc, char **argv);
89 extern int fips_shatest_main(int argc, char **argv);
90 extern int fips_test_suite_main(int argc, char **argv);
91
92 #include "fips_aesavs.c"
93 #include "fips_cmactest.c"
94 #include "fips_desmovs.c"
95 #include "fips_dhvs.c"
96 #include "fips_drbgvs.c"
97 #include "fips_dssvs.c"
98 #include "fips_ecdhvs.c"
99 #include "fips_ecdsavs.c"
100 #include "fips_gcmtest.c"
101 #include "fips_hmactest.c"
102 #include "fips_rngvs.c"
103 #include "fips_rsagtest.c"
104 #include "fips_rsastest.c"
105 #include "fips_rsavtest.c"
106 #include "fips_shatest.c"
107 #include "fips_test_suite.c"
108
109 typedef struct
110         {
111         const char *name;
112         int (*func)(int argc, char **argv);
113         } ALGVS_FUNCTION;
114
115 static ALGVS_FUNCTION algvs[] = {
116         {"fips_aesavs", fips_aesavs_main}, 
117         {"fips_cmactest", fips_cmactest_main}, 
118         {"fips_desmovs", fips_desmovs_main}, 
119         {"fips_dhvs", fips_dhvs_main}, 
120         {"fips_drbgvs", fips_drbgvs_main}, 
121         {"fips_dssvs", fips_dssvs_main}, 
122         {"fips_ecdhvs", fips_ecdhvs_main}, 
123         {"fips_ecdsavs", fips_ecdsavs_main}, 
124         {"fips_gcmtest", fips_gcmtest_main}, 
125         {"fips_hmactest", fips_hmactest_main}, 
126         {"fips_rngvs", fips_rngvs_main}, 
127         {"fips_rsagtest", fips_rsagtest_main}, 
128         {"fips_rsastest", fips_rsastest_main}, 
129         {"fips_rsavtest", fips_rsavtest_main}, 
130         {"fips_shatest", fips_shatest_main}, 
131         {"fips_test_suite", fips_test_suite_main}, 
132         {NULL, 0}
133         };
134
135 /* Argument parsing taken from apps/apps.c */
136
137 typedef struct args_st
138         {
139         char **data;
140         int count;
141         } ARGS;
142
143 static int chopup_args(ARGS *arg, char *buf, int *argc, char **argv[])
144         {
145         int num,i;
146         char *p;
147
148         *argc=0;
149         *argv=NULL;
150
151         i=0;
152         if (arg->count == 0)
153                 {
154                 arg->count=20;
155                 arg->data=(char **)OPENSSL_malloc(sizeof(char *)*arg->count);
156                 }
157         for (i=0; i<arg->count; i++)
158                 arg->data[i]=NULL;
159
160         num=0;
161         p=buf;
162         for (;;)
163                 {
164                 /* first scan over white space */
165                 if (!*p) break;
166                 while (*p && ((*p == ' ') || (*p == '\t') || (*p == '\n')))
167                         p++;
168                 if (!*p) break;
169
170                 /* The start of something good :-) */
171                 if (num >= arg->count)
172                         {
173                         fprintf(stderr, "Too many arguments!!\n");
174                         return 0;
175                         }
176                 arg->data[num++]=p;
177
178                 /* now look for the end of this */
179                 if ((*p == '\'') || (*p == '\"')) /* scan for closing quote */
180                         {
181                         i= *(p++);
182                         arg->data[num-1]++; /* jump over quote */
183                         while (*p && (*p != i))
184                                 p++;
185                         *p='\0';
186                         }
187                 else
188                         {
189                         while (*p && ((*p != ' ') &&
190                                 (*p != '\t') && (*p != '\n')))
191                                 p++;
192
193                         if (*p == '\0')
194                                 p--;
195                         else
196                                 *p='\0';
197                         }
198                 p++;
199                 }
200         *argc=num;
201         *argv=arg->data;
202         return(1);
203         }
204
205 static int run_prg(int argc, char **argv)
206         {
207         ALGVS_FUNCTION *t;
208         const char *prg_name;
209         prg_name = strrchr(argv[0], '/');
210         if (prg_name)
211                 prg_name++;
212         else
213                 prg_name = argv[0];
214         for (t = algvs; t->name; t++)
215                 {
216                 if (!strcmp(prg_name, t->name))
217                         return t->func(argc, argv);
218                 }
219         return -100;
220         }
221
222 int main(int argc, char **argv)
223         {
224         char buf[1024];
225         char **args = argv + 1;
226         const char *sname = "fipstests.sh";
227         ARGS arg;
228         int xargc;
229         char **xargv;
230         int lineno = 0, badarg = 0;
231         int nerr = 0, quiet = 0, verbose = 0;
232         int rv;
233         FILE *in = NULL;
234 #ifdef FIPS_ALGVS_MEMCHECK
235         CRYPTO_malloc_debug_init();
236         OPENSSL_init();
237         CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
238         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
239 #endif
240
241         if (*args && *args[0] != '-')
242                 {
243                 rv = run_prg(argc - 1, args);
244 #ifdef FIPS_ALGVS_MEMCHECK
245                 CRYPTO_mem_leaks_fp(stderr);
246 #endif
247                 return rv;
248                 }
249         while (!badarg && *args && *args[0] == '-')
250                 {
251                 if (!strcmp(*args, "-script"))
252                         {
253                         if (args[1])
254                                 {
255                                 args++;
256                                 sname = *args;
257                                 }
258                         else
259                                 badarg = 1;
260                         }
261                 else if (!strcmp(*args, "-quiet"))
262                         quiet = 1;
263                 else if (!strcmp(*args, "-verbose"))
264                         verbose = 1;
265                 else
266                         badarg = 1;
267                 args++;
268                 }
269
270         if (badarg)
271                 {
272                 fprintf(stderr, "Error processing arguments\n");
273                 return 1;
274                 }
275
276         in = fopen(sname, "r");
277         if (!in)
278                 {
279                 fprintf(stderr, "Error opening script file \"%s\"\n", sname);
280                 return 1;
281                 }
282
283         arg.data = NULL;
284         arg.count = 0;
285
286         while (fgets(buf, sizeof(buf), in))
287                 {
288                 lineno++;
289                 if (!chopup_args(&arg, buf, &xargc, &xargv))
290                         fprintf(stderr, "Error processing line %d\n", lineno);
291                 else
292                         {
293                         if (!quiet)
294                                 {
295                                 int i;
296                                 int narg = verbose ? xargc : xargc - 2;
297                                 printf("Running command line:");
298                                 for (i = 0; i < narg; i++)
299                                         printf(" %s", xargv[i]);
300                                 printf("\n");
301                                 }
302                         rv = run_prg(xargc, xargv);
303                         if (FIPS_module_mode())
304                                 FIPS_module_mode_set(0, NULL);
305                         if (rv != 0)
306                                 nerr++;
307                         if (rv == -100)
308                                 fprintf(stderr, "ERROR: Command not found\n");
309                         else if (rv != 0)
310                                 fprintf(stderr, "ERROR: returned %d\n", rv);
311                         else if (verbose)
312                                 printf("\tCommand run successfully\n");
313                         }
314                 }
315
316         if (!quiet)
317                 printf("Completed with %d errors\n", nerr);
318
319         if (arg.data)
320                 OPENSSL_free(arg.data);
321
322         fclose(in);
323 #ifdef FIPS_ALGVS_MEMCHECK
324         CRYPTO_mem_leaks_fp(stderr);
325 #endif
326         if (nerr == 0)
327                 return 0;
328         return 1;
329         }
330 #endif