crypto/openssl/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 void do_print_errors(void);
  51 int hex2bin(const char *in, unsigned char *out);
  52 unsigned char *hex2bin_m(const char *in, long *plen);
  53 int do_hex2bn(BIGNUM **pr, const char *in);
  54 int do_bn_print(FILE *out, BIGNUM *bn);
  55 int do_bn_print_name(FILE *out, const char *name, BIGNUM *bn);
  56 int parse_line(char **pkw, char **pval, char *linebuf, char *olinebuf);
  57 BIGNUM *hex2bn(const char *in);
  58 int bin2hex(const unsigned char *in,int len,char *out);
  59 void pv(const char *tag,const unsigned char *val,int len);
  60 int tidy_line(char *linebuf, char *olinebuf);
  61 int bint2bin(const char *in, int len, unsigned char *out);
  62 int bin2bint(const unsigned char *in,int len,char *out);
  63 void PrintValue(char *tag, unsigned char *val, int len);
  64 void OutputValue(char *tag, unsigned char *val, int len, FILE *rfp,int bitmode);
  65
  66 void do_print_errors(void)
  67         {
  68         const char *file, *data;
  69         int line, flags;
  70         unsigned long l;
  71         while ((l = ERR_get_error_line_data(&file, &line, &data, &flags)))
  72                 {
  73                 fprintf(stderr, "ERROR:%lx:lib=%d,func=%d,reason=%d"
  74                                 ":file=%s:line=%d:%s\n",
  75                         l, ERR_GET_LIB(l), ERR_GET_FUNC(l), ERR_GET_REASON(l),
  76                         file, line, flags & ERR_TXT_STRING ? data : "");
  77                 }
  78         }
  79
  80 int hex2bin(const char *in, unsigned char *out)
  81     {
  82     int n1, n2;
  83     unsigned char ch;
  84
  85     for (n1=0,n2=0 ; in[n1] && in[n1] != '\n' ; )
  86         { /* first byte */
  87         if ((in[n1] >= '0') && (in[n1] <= '9'))
  88             ch = in[n1++] - '0';
  89         else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
  90             ch = in[n1++] - 'A' + 10;
  91         else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
  92             ch = in[n1++] - 'a' + 10;
  93         else
  94             return -1;
  95         if(!in[n1])
  96             {
  97             out[n2++]=ch;
  98             break;
  99             }
 100         out[n2] = ch << 4;
 101         /* second byte */
 102         if ((in[n1] >= '0') && (in[n1] <= '9'))
 103             ch = in[n1++] - '0';
 104         else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
 105             ch = in[n1++] - 'A' + 10;
 106         else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
 107             ch = in[n1++] - 'a' + 10;
 108         else
 109             return -1;
 110         out[n2++] |= ch;
 111         }
 112     return n2;
 113     }
 114
 115 unsigned char *hex2bin_m(const char *in, long *plen)
 116         {
 117         unsigned char *p;
 118         p = OPENSSL_malloc((strlen(in) + 1)/2);
 119         *plen = hex2bin(in, p);
 120         return p;
 121         }
 122
 123 int do_hex2bn(BIGNUM **pr, const char *in)
 124         {
 125         unsigned char *p;
 126         long plen;
 127         int r = 0;
 128         p = hex2bin_m(in, &plen);
 129         if (!p)
 130                 return 0;
 131         if (!*pr)
 132                 *pr = BN_new();
 133         if (!*pr)
 134                 return 0;
 135         if (BN_bin2bn(p, plen, *pr))
 136                 r = 1;
 137         OPENSSL_free(p);
 138         return r;
 139         }
 140
 141 int do_bn_print(FILE *out, BIGNUM *bn)
 142         {
 143         int len, i;
 144         unsigned char *tmp;
 145         len = BN_num_bytes(bn);
 146         if (len == 0)
 147                 {
 148                 fputs("00", out);
 149                 return 1;
 150                 }
 151
 152         tmp = OPENSSL_malloc(len);
 153         if (!tmp)
 154                 {
 155                 fprintf(stderr, "Memory allocation error\n");
 156                 return 0;
 157                 }
 158         BN_bn2bin(bn, tmp);
 159         for (i = 0; i < len; i++)
 160                 fprintf(out, "%02x", tmp[i]);
 161         OPENSSL_free(tmp);
 162         return 1;
 163         }
 164
 165 int do_bn_print_name(FILE *out, const char *name, BIGNUM *bn)
 166         {
 167         int r;
 168         fprintf(out, "%s = ", name);
 169         r = do_bn_print(out, bn);
 170         if (!r)
 171                 return 0;
 172         fputs("\n", out);
 173         return 1;
 174         }
 175
 176 int parse_line(char **pkw, char **pval, char *linebuf, char *olinebuf)
 177         {
 178         char *keyword, *value, *p, *q;
 179         strcpy(linebuf, olinebuf);
 180         keyword = linebuf;
 181         /* Skip leading space */
 182         while (isspace((unsigned char)*keyword))
 183                 keyword++;
 184
 185         /* Look for = sign */
 186         p = strchr(linebuf, '=');
 187
 188         /* If no '=' exit */
 189         if (!p)
 190                 return 0;
 191
 192         q = p - 1;
 193
 194         /* Remove trailing space */
 195         while (isspace((unsigned char)*q))
 196                 *q-- = 0;
 197
 198         *p = 0;
 199         value = p + 1;
 200
 201         /* Remove leading space from value */
 202         while (isspace((unsigned char)*value))
 203                 value++;
 204
 205         /* Remove trailing space from value */
 206         p = value + strlen(value) - 1;
 207
 208         while (*p == '\n' || isspace((unsigned char)*p))
 209                 *p-- = 0;
 210
 211         *pkw = keyword;
 212         *pval = value;
 213         return 1;
 214         }
 215
 216 BIGNUM *hex2bn(const char *in)
 217     {
 218     BIGNUM *p=NULL;
 219
 220     if (!do_hex2bn(&p, in))
 221         return NULL;
 222
 223     return p;
 224     }
 225
 226 int bin2hex(const unsigned char *in,int len,char *out)
 227     {
 228     int n1, n2;
 229     unsigned char ch;
 230
 231     for (n1=0,n2=0 ; n1 < len ; ++n1)
 232         {
 233         ch=in[n1] >> 4;
 234         if (ch <= 0x09)
 235             out[n2++]=ch+'0';
 236         else
 237             out[n2++]=ch-10+'a';
 238         ch=in[n1] & 0x0f;
 239         if(ch <= 0x09)
 240             out[n2++]=ch+'0';
 241         else
 242             out[n2++]=ch-10+'a';
 243         }
 244     out[n2]='\0';
 245     return n2;
 246     }
 247
 248 void pv(const char *tag,const unsigned char *val,int len)
 249     {
 250     char obuf[2048];
 251
 252     bin2hex(val,len,obuf);
 253     printf("%s = %s\n",tag,obuf);
 254     }
 255
 256 /* To avoid extensive changes to test program at this stage just convert
 257  * the input line into an acceptable form. Keyword lines converted to form
 258  * "keyword = value\n" no matter what white space present, all other lines
 259  * just have leading and trailing space removed.
 260  */
 261
 262 int tidy_line(char *linebuf, char *olinebuf)
 263         {
 264         char *keyword, *value, *p, *q;
 265         strcpy(linebuf, olinebuf);
 266         keyword = linebuf;
 267         /* Skip leading space */
 268         while (isspace((unsigned char)*keyword))
 269                 keyword++;
 270         /* Look for = sign */
 271         p = strchr(linebuf, '=');
 272
 273         /* If no '=' just chop leading, trailing ws */
 274         if (!p)
 275                 {
 276                 p = keyword + strlen(keyword) - 1;
 277                 while (*p == '\n' || isspace((unsigned char)*p))
 278                         *p-- = 0;
 279                 strcpy(olinebuf, keyword);
 280                 strcat(olinebuf, "\n");
 281                 return 1;
 282                 }
 283
 284         q = p - 1;
 285
 286         /* Remove trailing space */
 287         while (isspace((unsigned char)*q))
 288                 *q-- = 0;
 289
 290         *p = 0;
 291         value = p + 1;
 292
 293         /* Remove leading space from value */
 294         while (isspace((unsigned char)*value))
 295                 value++;
 296
 297         /* Remove trailing space from value */
 298         p = value + strlen(value) - 1;
 299
 300         while (*p == '\n' || isspace((unsigned char)*p))
 301                 *p-- = 0;
 302
 303         strcpy(olinebuf, keyword);
 304         strcat(olinebuf, " = ");
 305         strcat(olinebuf, value);
 306         strcat(olinebuf, "\n");
 307
 308         return 1;
 309         }
 310
 311 /* NB: this return the number of _bits_ read */
 312 int bint2bin(const char *in, int len, unsigned char *out)
 313     {
 314     int n;
 315
 316     memset(out,0,len);
 317     for(n=0 ; n < len ; ++n)
 318         if(in[n] == '1')
 319             out[n/8]|=(0x80 >> (n%8));
 320     return len;
 321     }
 322
 323 int bin2bint(const unsigned char *in,int len,char *out)
 324     {
 325     int n;
 326
 327     for(n=0 ; n < len ; ++n)
 328         out[n]=(in[n/8]&(0x80 >> (n%8))) ? '1' : '0';
 329     return n;
 330     }
 331
 332 /*-----------------------------------------------*/
 333
 334 void PrintValue(char *tag, unsigned char *val, int len)
 335 {
 336 #if VERBOSE
 337   char obuf[2048];
 338   int olen;
 339   olen = bin2hex(val, len, obuf);
 340   printf("%s = %.*s\n", tag, olen, obuf);
 341 #endif
 342 }
 343
 344 void OutputValue(char *tag, unsigned char *val, int len, FILE *rfp,int bitmode)
 345     {
 346     char obuf[2048];
 347     int olen;
 348
 349     if(bitmode)
 350         olen=bin2bint(val,len,obuf);
 351     else
 352         olen=bin2hex(val,len,obuf);
 353
 354     fprintf(rfp, "%s = %.*s\n", tag, olen, obuf);
 355 #if VERBOSE
 356     printf("%s = %.*s\n", tag, olen, obuf);
 357 #endif
 358     }
 359