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