AppleCSP/open_ssl/bn/bn_print.c

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /* crypto/bn/bn_print.c */
  20 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  21  * All rights reserved.
  22  *
  23  * This package is an SSL implementation written
  24  * by Eric Young (eay@cryptsoft.com).
  25  * The implementation was written so as to conform with Netscapes SSL.
  26  *
  27  * This library is free for commercial and non-commercial use as long as
  28  * the following conditions are aheared to.  The following conditions
  29  * apply to all code found in this distribution, be it the RC4, RSA,
  30  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  31  * included with this distribution is covered by the same copyright terms
  32  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  33  *
  34  * Copyright remains Eric Young's, and as such any Copyright notices in
  35  * the code are not to be removed.
  36  * If this package is used in a product, Eric Young should be given attribution
  37  * as the author of the parts of the library used.
  38  * This can be in the form of a textual message at program startup or
  39  * in documentation (online or textual) provided with the package.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. All advertising materials mentioning features or use of this software
  50  *    must display the following acknowledgement:
  51  *    "This product includes cryptographic software written by
  52  *     Eric Young (eay@cryptsoft.com)"
  53  *    The word 'cryptographic' can be left out if the rouines from the library
  54  *    being used are not cryptographic related :-).
  55  * 4. If you include any Windows specific code (or a derivative thereof) from
  56  *    the apps directory (application code) you must include an acknowledgement:
  57  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  58  *
  59  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  69  * SUCH DAMAGE.
  70  *
  71  * The licence and distribution terms for any publically available version or
  72  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  73  * copied and put under another distribution licence
  74  * [including the GNU Public Licence.]
  75  */
  76
  77 #include <stdio.h>
  78 #include <ctype.h>
  79 #include "cryptlib.h"
  80 #include <openssl/buffer.h>
  81 #include "bn_lcl.h"
  82
  83 static const char *Hex="0123456789ABCDEF";
  84
  85 /* Must 'Free' the returned data */
  86 char *BN_bn2hex(const BIGNUM *a)
  87         {
  88         int i,j,v,z=0;
  89         char *buf;
  90         char *p;
  91
  92         buf=(char *)Malloc(a->top*BN_BYTES*2+2);
  93         if (buf == NULL)
  94                 {
  95                 BNerr(BN_F_BN_BN2HEX,ERR_R_MALLOC_FAILURE);
  96                 goto err;
  97                 }
  98         p=buf;
  99         if (a->neg) *(p++)='-';
 100         if (a->top == 0) *(p++)='0';
 101         for (i=a->top-1; i >=0; i--)
 102                 {
 103                 for (j=BN_BITS2-8; j >= 0; j-=8)
 104                         {
 105                         /* strip leading zeros */
 106                         v=((int)(a->d[i]>>(long)j))&0xff;
 107                         if (z || (v != 0))
 108                                 {
 109                                 *(p++)=Hex[v>>4];
 110                                 *(p++)=Hex[v&0x0f];
 111                                 z=1;
 112                                 }
 113                         }
 114                 }
 115         *p='\0';
 116 err:
 117         return(buf);
 118         }
 119
 120 /* Must 'Free' the returned data */
 121 char *BN_bn2dec(const BIGNUM *a)
 122         {
 123         int i=0,num;
 124         char *buf=NULL;
 125         char *p;
 126         BIGNUM *t=NULL;
 127         BN_ULONG *bn_data=NULL,*lp;
 128
 129         i=BN_num_bits(a)*3;
 130         num=(i/10+i/1000+3)+1;
 131         bn_data=(BN_ULONG *)Malloc((num/BN_DEC_NUM+1)*sizeof(BN_ULONG));
 132         buf=(char *)Malloc(num+3);
 133         if ((buf == NULL) || (bn_data == NULL))
 134                 {
 135                 BNerr(BN_F_BN_BN2DEC,ERR_R_MALLOC_FAILURE);
 136                 goto err;
 137                 }
 138         if ((t=BN_dup(a)) == NULL) goto err;
 139
 140         p=buf;
 141         lp=bn_data;
 142         if (t->neg) *(p++)='-';
 143         if (t->top == 0)
 144                 {
 145                 *(p++)='0';
 146                 *(p++)='\0';
 147                 }
 148         else
 149                 {
 150                 i=0;
 151                 while (!BN_is_zero(t))
 152                         {
 153                         *lp=BN_div_word(t,BN_DEC_CONV);
 154                         lp++;
 155                         }
 156                 lp--;
 157                 /* We now have a series of blocks, BN_DEC_NUM chars
 158                  * in length, where the last one needs truncation.
 159                  * The blocks need to be reversed in order. */
 160                 sprintf(p,BN_DEC_FMT1,*lp);
 161                 while (*p) p++;
 162                 while (lp != bn_data)
 163                         {
 164                         lp--;
 165                         sprintf(p,BN_DEC_FMT2,*lp);
 166                         while (*p) p++;
 167                         }
 168                 }
 169 err:
 170         if (bn_data != NULL) Free(bn_data);
 171         if (t != NULL) BN_free(t);
 172         return(buf);
 173         }
 174
 175 int BN_hex2bn(BIGNUM **bn, const char *a)
 176         {
 177         BIGNUM *ret=NULL;
 178         BN_ULONG l=0;
 179         int neg=0,h,m,i,j,k,c;
 180         int num;
 181
 182         if ((a == NULL) || (*a == '\0')) return(0);
 183
 184         if (*a == '-') { neg=1; a++; }
 185
 186         for (i=0; isxdigit((unsigned char) a[i]); i++)
 187                 ;
 188
 189         num=i+neg;
 190         if (bn == NULL) return(num);
 191
 192         /* a is the start of the hex digits, and it is 'i' long */
 193         if (*bn == NULL)
 194                 {
 195                 if ((ret=BN_new()) == NULL) return(0);
 196                 }
 197         else
 198                 {
 199                 ret= *bn;
 200                 BN_zero(ret);
 201                 }
 202
 203         /* i is the number of hex digests; */
 204         if (bn_expand(ret,i*4) == NULL) goto err;
 205
 206         j=i; /* least significant 'hex' */
 207         m=0;
 208         h=0;
 209         while (j > 0)
 210                 {
 211                 m=((BN_BYTES*2) <= j)?(BN_BYTES*2):j;
 212                 l=0;
 213                 for (;;)
 214                         {
 215                         c=a[j-m];
 216                         if ((c >= '0') && (c <= '9')) k=c-'0';
 217                         else if ((c >= 'a') && (c <= 'f')) k=c-'a'+10;
 218                         else if ((c >= 'A') && (c <= 'F')) k=c-'A'+10;
 219                         else k=0; /* paranoia */
 220                         l=(l<<4)|k;
 221
 222                         if (--m <= 0)
 223                                 {
 224                                 ret->d[h++]=l;
 225                                 break;
 226                                 }
 227                         }
 228                 j-=(BN_BYTES*2);
 229                 }
 230         ret->top=h;
 231         bn_fix_top(ret);
 232         ret->neg=neg;
 233
 234         *bn=ret;
 235         return(num);
 236 err:
 237         if (*bn == NULL) BN_free(ret);
 238         return(0);
 239         }
 240
 241 int BN_dec2bn(BIGNUM **bn, const char *a)
 242         {
 243         BIGNUM *ret=NULL;
 244         BN_ULONG l=0;
 245         int neg=0,i,j;
 246         int num;
 247
 248         if ((a == NULL) || (*a == '\0')) return(0);
 249         if (*a == '-') { neg=1; a++; }
 250
 251         for (i=0; isdigit((unsigned char) a[i]); i++)
 252                 ;
 253
 254         num=i+neg;
 255         if (bn == NULL) return(num);
 256
 257         /* a is the start of the digits, and it is 'i' long.
 258          * We chop it into BN_DEC_NUM digits at a time */
 259         if (*bn == NULL)
 260                 {
 261                 if ((ret=BN_new()) == NULL) return(0);
 262                 }
 263         else
 264                 {
 265                 ret= *bn;
 266                 BN_zero(ret);
 267                 }
 268
 269         /* i is the number of digests, a bit of an over expand; */
 270         if (bn_expand(ret,i*4) == NULL) goto err;
 271
 272         j=BN_DEC_NUM-(i%BN_DEC_NUM);
 273         if (j == BN_DEC_NUM) j=0;
 274         l=0;
 275         while (*a)
 276                 {
 277                 l*=10;
 278                 l+= *a-'0';
 279                 a++;
 280                 if (++j == BN_DEC_NUM)
 281                         {
 282                         BN_mul_word(ret,BN_DEC_CONV);
 283                         BN_add_word(ret,l);
 284                         l=0;
 285                         j=0;
 286                         }
 287                 }
 288         ret->neg=neg;
 289
 290         bn_fix_top(ret);
 291         *bn=ret;
 292         return(num);
 293 err:
 294         if (*bn == NULL) BN_free(ret);
 295         return(0);
 296         }
 297
 298 #ifndef NO_BIO
 299 #ifndef NO_FP_API
 300 int BN_print_fp(FILE *fp, const BIGNUM *a)
 301         {
 302         BIO *b;
 303         int ret;
 304
 305         if ((b=BIO_new(BIO_s_file())) == NULL)
 306                 return(0);
 307         BIO_set_fp(b,fp,BIO_NOCLOSE);
 308         ret=BN_print(b,a);
 309         BIO_free(b);
 310         return(ret);
 311         }
 312 #endif
 313
 314 int BN_print(BIO *bp, const BIGNUM *a)
 315         {
 316         int i,j,v,z=0;
 317         int ret=0;
 318
 319         if ((a->neg) && (BIO_write(bp,"-",1) != 1)) goto end;
 320         if ((a->top == 0) && (BIO_write(bp,"0",1) != 1)) goto end;
 321         for (i=a->top-1; i >=0; i--)
 322                 {
 323                 for (j=BN_BITS2-4; j >= 0; j-=4)
 324                         {
 325                         /* strip leading zeros */
 326                         v=((int)(a->d[i]>>(long)j))&0x0f;
 327                         if (z || (v != 0))
 328                                 {
 329                                 if (BIO_write(bp,&(Hex[v]),1) != 1)
 330                                         goto end;
 331                                 z=1;
 332                                 }
 333                         }
 334                 }
 335         ret=1;
 336 end:
 337         return(ret);
 338         }
 339 #endif
 340
 341 #ifdef BN_DEBUG
 342 void bn_dump1(FILE *o, const char *a, BN_ULONG *b,int n)
 343         {
 344         int i;
 345         fprintf(o, "%s=", a);
 346         for (i=n-1;i>=0;i--)
 347                 fprintf(o, "%08lX", b[i]); /* assumes 32-bit BN_ULONG */
 348         fprintf(o, "\n");
 349         }
 350 #endif