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