Add FIPS selftests for ECDH algorithm.
[openssl.git] / fips / fips_utl.h
1 /* ====================================================================
2  * Copyright (c) 2011 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 #define OPENSSL_FIPSAPI
51
52 #include <openssl/fips_rand.h>
53 #include <openssl/objects.h>
54
55 int hex2bin(const char *in, unsigned char *out);
56 unsigned char *hex2bin_m(const char *in, long *plen);
57 int do_hex2bn(BIGNUM **pr, const char *in);
58 int do_bn_print(FILE *out, const BIGNUM *bn);
59 int do_bn_print_name(FILE *out, const char *name, const BIGNUM *bn);
60 int parse_line(char **pkw, char **pval, char *linebuf, char *olinebuf);
61 int parse_line2(char **pkw, char **pval, char *linebuf, char *olinebuf, int eol);
62 BIGNUM *hex2bn(const char *in);
63 int tidy_line(char *linebuf, char *olinebuf);
64 int bint2bin(const char *in, int len, unsigned char *out);
65 int bin2bint(const unsigned char *in,int len,char *out);
66 void PrintValue(char *tag, unsigned char *val, int len);
67 void OutputValue(char *tag, unsigned char *val, int len, FILE *rfp,int bitmode);
68 void fips_algtest_init(void);
69 void do_entropy_stick(void);
70 int fips_strncasecmp(const char *str1, const char *str2, size_t n);
71 int fips_strcasecmp(const char *str1, const char *str2);
72
73 static int no_err;
74
75 static void put_err_cb(int lib, int func,int reason,const char *file,int line)
76         {
77                 if (no_err)
78                         return;
79                 fprintf(stderr, "ERROR:%08lX:lib=%d,func=%d,reason=%d"
80                                 ":file=%s:line=%d\n",
81                         ERR_PACK(lib, func, reason),
82                         lib, func, reason, file, line);
83         }
84
85 static void add_err_cb(int num, va_list args)
86         {
87         int i;
88         char *str;
89         if (no_err)
90                 return;
91         fputs("\t", stderr);
92         for (i = 0; i < num; i++)
93                 {
94                 str = va_arg(args, char *);
95                 if (str)
96                         fputs(str, stderr);
97                 }
98         fputs("\n", stderr);
99         }
100
101 /* Dummy Entropy to keep DRBG happy. WARNING: THIS IS TOTALLY BOGUS
102  * HAS ZERO SECURITY AND MUST NOT BE USED IN REAL APPLICATIONS.
103  */
104
105 static unsigned char dummy_entropy[1024];
106
107 static size_t dummy_cb(DRBG_CTX *ctx, unsigned char **pout,
108                                 int entropy, size_t min_len, size_t max_len)
109         {
110         *pout = dummy_entropy;
111         return min_len;
112         }
113
114 static int entropy_stick = 0;
115
116 static void fips_algtest_init_nofips(void)
117         {
118         DRBG_CTX *ctx;
119         size_t i;
120         FIPS_set_error_callbacks(put_err_cb, add_err_cb);
121         for (i = 0; i < sizeof(dummy_entropy); i++)
122                 dummy_entropy[i] = i & 0xff;
123         if (entropy_stick)
124                 memcpy(dummy_entropy + 32, dummy_entropy + 16, 16);
125         ctx = FIPS_get_default_drbg();
126         FIPS_drbg_init(ctx, NID_aes_256_ctr, DRBG_FLAG_CTR_USE_DF);
127         FIPS_drbg_set_callbacks(ctx, dummy_cb, 0, 16, dummy_cb, 0);
128         FIPS_drbg_instantiate(ctx, dummy_entropy, 10);
129         FIPS_rand_set_method(FIPS_drbg_method());
130         }
131
132 void do_entropy_stick(void)
133         {
134         entropy_stick = 1;
135         }
136
137 void fips_algtest_init(void)
138         {
139         fips_algtest_init_nofips();
140         if (!FIPS_module_mode_set(1))
141                 {
142                 fprintf(stderr, "Error entering FIPS mode\n");
143                 exit(1);
144                 }
145         }
146
147 int hex2bin(const char *in, unsigned char *out)
148     {
149     int n1, n2, isodd = 0;
150     unsigned char ch;
151
152     n1 = strlen(in);
153     if (in[n1 - 1] == '\n')
154         n1--;
155
156     if (n1 & 1)
157         isodd = 1;
158
159     for (n1=0,n2=0 ; in[n1] && in[n1] != '\n' ; )
160         { /* first byte */
161         if ((in[n1] >= '0') && (in[n1] <= '9'))
162             ch = in[n1++] - '0';
163         else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
164             ch = in[n1++] - 'A' + 10;
165         else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
166             ch = in[n1++] - 'a' + 10;
167         else
168             return -1;
169         if(!in[n1])
170             {
171             out[n2++]=ch;
172             break;
173             }
174         /* If input is odd length first digit is least significant: assumes
175          * all digits valid hex and null terminated which is true for the
176          * strings we pass.
177          */
178         if (n1 == 1 && isodd)
179                 {
180                 out[n2++] = ch;
181                 continue;
182                 }
183         out[n2] = ch << 4;
184         /* second byte */
185         if ((in[n1] >= '0') && (in[n1] <= '9'))
186             ch = in[n1++] - '0';
187         else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
188             ch = in[n1++] - 'A' + 10;
189         else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
190             ch = in[n1++] - 'a' + 10;
191         else
192             return -1;
193         out[n2++] |= ch;
194         }
195     return n2;
196     }
197
198 unsigned char *hex2bin_m(const char *in, long *plen)
199         {
200         unsigned char *p;
201         if (strlen(in) == 0)
202                 {
203                 *plen = 0;
204                 return OPENSSL_malloc(1);
205                 }
206         p = OPENSSL_malloc((strlen(in) + 1)/2);
207         *plen = hex2bin(in, p);
208         return p;
209         }
210
211 int do_hex2bn(BIGNUM **pr, const char *in)
212         {
213         unsigned char *p;
214         long plen;
215         int r = 0;
216         p = hex2bin_m(in, &plen);
217         if (!p)
218                 return 0;
219         if (!*pr)
220                 *pr = BN_new();
221         if (!*pr)
222                 return 0;
223         if (BN_bin2bn(p, plen, *pr))
224                 r = 1;
225         OPENSSL_free(p);
226         return r;
227         }
228
229 int do_bn_print(FILE *out, const BIGNUM *bn)
230         {
231         int len, i;
232         unsigned char *tmp;
233         len = BN_num_bytes(bn);
234         if (len == 0)
235                 {
236                 fputs("00", out);
237                 return 1;
238                 }
239
240         tmp = OPENSSL_malloc(len);
241         if (!tmp)
242                 {
243                 fprintf(stderr, "Memory allocation error\n");
244                 return 0;
245                 }
246         BN_bn2bin(bn, tmp);
247         for (i = 0; i < len; i++)
248                 fprintf(out, "%02x", tmp[i]);
249         OPENSSL_free(tmp);
250         return 1;
251         }
252
253 int do_bn_print_name(FILE *out, const char *name, const BIGNUM *bn)
254         {
255         int r;
256         fprintf(out, "%s = ", name);
257         r = do_bn_print(out, bn);
258         if (!r)
259                 return 0;
260         fputs("\n", out);
261         return 1;
262         }
263
264 int parse_line(char **pkw, char **pval, char *linebuf, char *olinebuf)
265         {
266         return parse_line2(pkw, pval, linebuf, olinebuf, 1);
267         }
268
269 int parse_line2(char **pkw, char **pval, char *linebuf, char *olinebuf, int eol)
270         {
271         char *keyword, *value, *p, *q;
272         strcpy(linebuf, olinebuf);
273         keyword = linebuf;
274         /* Skip leading space */
275         while (isspace((unsigned char)*keyword))
276                 keyword++;
277
278         /* Look for = sign */
279         p = strchr(linebuf, '=');
280
281         /* If no '=' exit */
282         if (!p)
283                 return 0;
284
285         q = p - 1;
286
287         /* Remove trailing space */
288         while (isspace((unsigned char)*q))
289                 *q-- = 0;
290
291         *p = 0;
292         value = p + 1;
293
294         /* Remove leading space from value */
295         while (isspace((unsigned char)*value))
296                 value++;
297
298         /* Remove trailing space from value */
299         p = value + strlen(value) - 1;
300
301         if (eol && *p != '\n')
302                 fprintf(stderr, "Warning: missing EOL\n");
303
304         while (*p == '\n' || isspace((unsigned char)*p))
305                 *p-- = 0;
306
307         *pkw = keyword;
308         *pval = value;
309         return 1;
310         }
311
312 BIGNUM *hex2bn(const char *in)
313     {
314     BIGNUM *p=NULL;
315
316     if (!do_hex2bn(&p, in))
317         return NULL;
318
319     return p;
320     }
321
322 /* To avoid extensive changes to test program at this stage just convert
323  * the input line into an acceptable form. Keyword lines converted to form
324  * "keyword = value\n" no matter what white space present, all other lines
325  * just have leading and trailing space removed.
326  */
327
328 int tidy_line(char *linebuf, char *olinebuf)
329         {
330         char *keyword, *value, *p, *q;
331         strcpy(linebuf, olinebuf);
332         keyword = linebuf;
333         /* Skip leading space */
334         while (isspace((unsigned char)*keyword))
335                 keyword++;
336         /* Look for = sign */
337         p = strchr(linebuf, '=');
338
339         /* If no '=' just chop leading, trailing ws */
340         if (!p)
341                 {
342                 p = keyword + strlen(keyword) - 1;
343                 while (*p == '\n' || isspace((unsigned char)*p))
344                         *p-- = 0;
345                 strcpy(olinebuf, keyword);
346                 strcat(olinebuf, "\n");
347                 return 1;
348                 }
349
350         q = p - 1;
351
352         /* Remove trailing space */
353         while (isspace((unsigned char)*q))
354                 *q-- = 0;
355
356         *p = 0;
357         value = p + 1;
358
359         /* Remove leading space from value */
360         while (isspace((unsigned char)*value))
361                 value++;
362
363         /* Remove trailing space from value */
364         p = value + strlen(value) - 1;
365
366         while (*p == '\n' || isspace((unsigned char)*p))
367                 *p-- = 0;
368
369         strcpy(olinebuf, keyword);
370         strcat(olinebuf, " = ");
371         strcat(olinebuf, value);
372         strcat(olinebuf, "\n");
373
374         return 1;
375         }
376
377 /* NB: this return the number of _bits_ read */
378 int bint2bin(const char *in, int len, unsigned char *out)
379     {
380     int n;
381
382     memset(out,0,len);
383     for(n=0 ; n < len ; ++n)
384         if(in[n] == '1')
385             out[n/8]|=(0x80 >> (n%8));
386     return len;
387     }
388
389 int bin2bint(const unsigned char *in,int len,char *out)
390     {
391     int n;
392
393     for(n=0 ; n < len ; ++n)
394         out[n]=(in[n/8]&(0x80 >> (n%8))) ? '1' : '0';
395     return n;
396     }
397
398 /*-----------------------------------------------*/
399
400 void PrintValue(char *tag, unsigned char *val, int len)
401 {
402 #ifdef VERBOSE
403         OutputValue(tag, val, len, stdout, 0);
404 #endif
405 }
406
407 void OutputValue(char *tag, unsigned char *val, int len, FILE *rfp,int bitmode)
408     {
409     char obuf[2048];
410     int olen;
411
412     if(bitmode)
413         {
414         olen=bin2bint(val,len,obuf);
415         fprintf(rfp, "%s = %.*s\n", tag, olen, obuf);
416         }
417     else
418         {
419         int i;
420         fprintf(rfp, "%s = ", tag);
421         for (i = 0; i < len; i++)
422                 fprintf(rfp, "%02x", val[i]);
423         fputs("\n", rfp);
424         }
425
426 #if VERBOSE
427     printf("%s = %.*s\n", tag, olen, obuf);
428 #endif
429     }
430
431 /* Not all platforms support strcasecmp and strncasecmp: implement versions
432  * in here to avoid need to include them in the validated module. Taken
433  * from crypto/o_str.c written by Richard Levitte (richard@levitte.org)
434  */
435
436 int fips_strncasecmp(const char *str1, const char *str2, size_t n)
437         {
438         while (*str1 && *str2 && n)
439                 {
440                 int res = toupper(*str1) - toupper(*str2);
441                 if (res) return res < 0 ? -1 : 1;
442                 str1++;
443                 str2++;
444                 n--;
445                 }
446         if (n == 0)
447                 return 0;
448         if (*str1)
449                 return 1;
450         if (*str2)
451                 return -1;
452         return 0;
453         }
454
455 int fips_strcasecmp(const char *str1, const char *str2)
456         {
457         return fips_strncasecmp(str1, str2, (size_t)-1);
458         }
459