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