bn_print.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381
  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 "internal/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. if (a->neg && BN_is_zero(a)) {
  71. /* "-0" == 3 bytes including NULL terminator */
  72. buf = OPENSSL_malloc(3);
  73. } else {
  74. buf = OPENSSL_malloc(a->top * BN_BYTES * 2 + 2);
  75. }
  76. if (buf == NULL) {
  77. BNerr(BN_F_BN_BN2HEX, ERR_R_MALLOC_FAILURE);
  78. goto err;
  79. }
  80. p = buf;
  81. if (a->neg)
  82. *(p++) = '-';
  83. if (BN_is_zero(a))
  84. *(p++) = '0';
  85. for (i = a->top - 1; i >= 0; i--) {
  86. for (j = BN_BITS2 - 8; j >= 0; j -= 8) {
  87. /* strip leading zeros */
  88. v = ((int)(a->d[i] >> (long)j)) & 0xff;
  89. if (z || (v != 0)) {
  90. *(p++) = Hex[v >> 4];
  91. *(p++) = Hex[v & 0x0f];
  92. z = 1;
  93. }
  94. }
  95. }
  96. *p = '\0';
  97. err:
  98. return (buf);
  99. }
  100. /* Must 'OPENSSL_free' the returned data */
  101. char *BN_bn2dec(const BIGNUM *a)
  102. {
  103. int i = 0, num, ok = 0;
  104. char *buf = NULL;
  105. char *p;
  106. BIGNUM *t = NULL;
  107. BN_ULONG *bn_data = NULL, *lp;
  108. /*-
  109. * get an upper bound for the length of the decimal integer
  110. * num <= (BN_num_bits(a) + 1) * log(2)
  111. * <= 3 * BN_num_bits(a) * 0.1001 + log(2) + 1 (rounding error)
  112. * <= BN_num_bits(a)/10 + BN_num_bits/1000 + 1 + 1
  113. */
  114. i = BN_num_bits(a) * 3;
  115. num = (i / 10 + i / 1000 + 1) + 1;
  116. bn_data = OPENSSL_malloc((num / BN_DEC_NUM + 1) * sizeof(BN_ULONG));
  117. buf = OPENSSL_malloc(num + 3);
  118. if ((buf == NULL) || (bn_data == NULL)) {
  119. BNerr(BN_F_BN_BN2DEC, ERR_R_MALLOC_FAILURE);
  120. goto err;
  121. }
  122. if ((t = BN_dup(a)) == NULL)
  123. goto err;
  124. #define BUF_REMAIN (num+3 - (size_t)(p - buf))
  125. p = buf;
  126. lp = bn_data;
  127. if (BN_is_zero(t)) {
  128. *(p++) = '0';
  129. *(p++) = '\0';
  130. } else {
  131. if (BN_is_negative(t))
  132. *p++ = '-';
  133. i = 0;
  134. while (!BN_is_zero(t)) {
  135. *lp = BN_div_word(t, BN_DEC_CONV);
  136. lp++;
  137. }
  138. lp--;
  139. /*
  140. * We now have a series of blocks, BN_DEC_NUM chars in length, where
  141. * the last one needs truncation. The blocks need to be reversed in
  142. * order.
  143. */
  144. BIO_snprintf(p, BUF_REMAIN, BN_DEC_FMT1, *lp);
  145. while (*p)
  146. p++;
  147. while (lp != bn_data) {
  148. lp--;
  149. BIO_snprintf(p, BUF_REMAIN, BN_DEC_FMT2, *lp);
  150. while (*p)
  151. p++;
  152. }
  153. }
  154. ok = 1;
  155. err:
  156. OPENSSL_free(bn_data);
  157. BN_free(t);
  158. if (ok)
  159. return buf;
  160. OPENSSL_free(buf);
  161. return NULL;
  162. }
  163. int BN_hex2bn(BIGNUM **bn, const char *a)
  164. {
  165. BIGNUM *ret = NULL;
  166. BN_ULONG l = 0;
  167. int neg = 0, h, m, i, j, k, c;
  168. int num;
  169. if ((a == NULL) || (*a == '\0'))
  170. return (0);
  171. if (*a == '-') {
  172. neg = 1;
  173. a++;
  174. }
  175. for (i = 0; isxdigit((unsigned char)a[i]); i++) ;
  176. num = i + neg;
  177. if (bn == NULL)
  178. return (num);
  179. /* a is the start of the hex digits, and it is 'i' long */
  180. if (*bn == NULL) {
  181. if ((ret = BN_new()) == NULL)
  182. return (0);
  183. } else {
  184. ret = *bn;
  185. BN_zero(ret);
  186. }
  187. /* i is the number of hex digests; */
  188. if (bn_expand(ret, i * 4) == NULL)
  189. goto err;
  190. j = i; /* least significant 'hex' */
  191. m = 0;
  192. h = 0;
  193. while (j > 0) {
  194. m = ((BN_BYTES * 2) <= j) ? (BN_BYTES * 2) : j;
  195. l = 0;
  196. for (;;) {
  197. c = a[j - m];
  198. if ((c >= '0') && (c <= '9'))
  199. k = c - '0';
  200. else if ((c >= 'a') && (c <= 'f'))
  201. k = c - 'a' + 10;
  202. else if ((c >= 'A') && (c <= 'F'))
  203. k = c - 'A' + 10;
  204. else
  205. k = 0; /* paranoia */
  206. l = (l << 4) | k;
  207. if (--m <= 0) {
  208. ret->d[h++] = l;
  209. break;
  210. }
  211. }
  212. j -= (BN_BYTES * 2);
  213. }
  214. ret->top = h;
  215. bn_correct_top(ret);
  216. ret->neg = neg;
  217. *bn = ret;
  218. bn_check_top(ret);
  219. return (num);
  220. err:
  221. if (*bn == NULL)
  222. BN_free(ret);
  223. return (0);
  224. }
  225. int BN_dec2bn(BIGNUM **bn, const char *a)
  226. {
  227. BIGNUM *ret = NULL;
  228. BN_ULONG l = 0;
  229. int neg = 0, i, j;
  230. int num;
  231. if ((a == NULL) || (*a == '\0'))
  232. return (0);
  233. if (*a == '-') {
  234. neg = 1;
  235. a++;
  236. }
  237. for (i = 0; isdigit((unsigned char)a[i]); i++) ;
  238. num = i + neg;
  239. if (bn == NULL)
  240. return (num);
  241. /*
  242. * a is the start of the digits, and it is 'i' long. We chop it into
  243. * BN_DEC_NUM digits at a time
  244. */
  245. if (*bn == NULL) {
  246. if ((ret = BN_new()) == NULL)
  247. return (0);
  248. } else {
  249. ret = *bn;
  250. BN_zero(ret);
  251. }
  252. /* i is the number of digests, a bit of an over expand; */
  253. if (bn_expand(ret, i * 4) == NULL)
  254. goto err;
  255. j = BN_DEC_NUM - (i % BN_DEC_NUM);
  256. if (j == BN_DEC_NUM)
  257. j = 0;
  258. l = 0;
  259. while (*a) {
  260. l *= 10;
  261. l += *a - '0';
  262. a++;
  263. if (++j == BN_DEC_NUM) {
  264. BN_mul_word(ret, BN_DEC_CONV);
  265. BN_add_word(ret, l);
  266. l = 0;
  267. j = 0;
  268. }
  269. }
  270. ret->neg = neg;
  271. bn_correct_top(ret);
  272. *bn = ret;
  273. bn_check_top(ret);
  274. return (num);
  275. err:
  276. if (*bn == NULL)
  277. BN_free(ret);
  278. return (0);
  279. }
  280. int BN_asc2bn(BIGNUM **bn, const char *a)
  281. {
  282. const char *p = a;
  283. if (*p == '-')
  284. p++;
  285. if (p[0] == '0' && (p[1] == 'X' || p[1] == 'x')) {
  286. if (!BN_hex2bn(bn, p + 2))
  287. return 0;
  288. } else {
  289. if (!BN_dec2bn(bn, p))
  290. return 0;
  291. }
  292. if (*a == '-')
  293. (*bn)->neg = 1;
  294. return 1;
  295. }
  296. # ifndef OPENSSL_NO_STDIO
  297. int BN_print_fp(FILE *fp, const BIGNUM *a)
  298. {
  299. BIO *b;
  300. int ret;
  301. if ((b = BIO_new(BIO_s_file())) == NULL)
  302. return (0);
  303. BIO_set_fp(b, fp, BIO_NOCLOSE);
  304. ret = BN_print(b, a);
  305. BIO_free(b);
  306. return (ret);
  307. }
  308. # endif
  309. int BN_print(BIO *bp, const BIGNUM *a)
  310. {
  311. int i, j, v, z = 0;
  312. int ret = 0;
  313. if ((a->neg) && (BIO_write(bp, "-", 1) != 1))
  314. goto end;
  315. if (BN_is_zero(a) && (BIO_write(bp, "0", 1) != 1))
  316. goto end;
  317. for (i = a->top - 1; i >= 0; i--) {
  318. for (j = BN_BITS2 - 4; j >= 0; j -= 4) {
  319. /* strip leading zeros */
  320. v = ((int)(a->d[i] >> (long)j)) & 0x0f;
  321. if (z || (v != 0)) {
  322. if (BIO_write(bp, &(Hex[v]), 1) != 1)
  323. goto end;
  324. z = 1;
  325. }
  326. }
  327. }
  328. ret = 1;
  329. end:
  330. return (ret);
  331. }
  332. char *BN_options(void)
  333. {
  334. static int init = 0;
  335. static char data[16];
  336. if (!init) {
  337. init++;
  338. #ifdef BN_LLONG
  339. BIO_snprintf(data, sizeof data, "bn(%d,%d)",
  340. (int)sizeof(BN_ULLONG) * 8, (int)sizeof(BN_ULONG) * 8);
  341. #else
  342. BIO_snprintf(data, sizeof data, "bn(%d,%d)",
  343. (int)sizeof(BN_ULONG) * 8, (int)sizeof(BN_ULONG) * 8);
  344. #endif
  345. }
  346. return (data);
  347. }