bn_print.c
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:8k
源码类别:

其他游戏

开发平台:

Visual C++

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