f3a7e6af63305b90bb212f0a50360b0325a81337
[openssl.git] / crypto / asn1 / a_int.c
1 /* crypto/asn1/a_int.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 "internal/cryptlib.h"
61 #include <limits.h>
62 #include <openssl/asn1.h>
63 #include <openssl/bn.h>
64 #include "asn1_locl.h"
65
66 ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x)
67 {
68     return ASN1_STRING_dup(x);
69 }
70
71 int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y)
72 {
73     int neg, ret;
74     /* Compare signs */
75     neg = x->type & V_ASN1_NEG;
76     if (neg != (y->type & V_ASN1_NEG)) {
77         if (neg)
78             return -1;
79         else
80             return 1;
81     }
82
83     ret = ASN1_STRING_cmp(x, y);
84
85     if (neg)
86         return -ret;
87     else
88         return ret;
89 }
90
91 /*-
92  * This converts a big endian buffer and sign into its content encoding.
93  * This is used for INTEGER and ENUMERATED types.
94  * The internal representation is an ASN1_STRING whose data is a big endian
95  * representation of the value, ignoring the sign. The sign is determined by
96  * the type: if type & V_ASN1_NEG is true it is negative, otherwise positive.
97  *
98  * Positive integers are no problem: they are almost the same as the DER
99  * encoding, except if the first byte is >= 0x80 we need to add a zero pad.
100  *
101  * Negative integers are a bit trickier...
102  * The DER representation of negative integers is in 2s complement form.
103  * The internal form is converted by complementing each octet and finally
104  * adding one to the result. This can be done less messily with a little trick.
105  * If the internal form has trailing zeroes then they will become FF by the
106  * complement and 0 by the add one (due to carry) so just copy as many trailing
107  * zeros to the destination as there are in the source. The carry will add one
108  * to the last none zero octet: so complement this octet and add one and finally
109  * complement any left over until you get to the start of the string.
110  *
111  * Padding is a little trickier too. If the first bytes is > 0x80 then we pad
112  * with 0xff. However if the first byte is 0x80 and one of the following bytes
113  * is non-zero we pad with 0xff. The reason for this distinction is that 0x80
114  * followed by optional zeros isn't padded.
115  */
116
117 static size_t i2c_ibuf(const unsigned char *b, size_t blen, int neg,
118                        unsigned char **pp)
119 {
120     int pad = 0;
121     size_t ret, i;
122     unsigned char *p, pb = 0;
123     const unsigned char *n;
124
125     if (b == NULL || blen == 0)
126         ret = 1;
127     else {
128         ret = blen;
129         i = b[0];
130         if (ret == 1 && i == 0)
131             neg = 0;
132         if (!neg && (i > 127)) {
133             pad = 1;
134             pb = 0;
135         } else if (neg) {
136             if (i > 128) {
137                 pad = 1;
138                 pb = 0xFF;
139             } else if (i == 128) {
140                 /*
141                  * Special case: if any other bytes non zero we pad:
142                  * otherwise we don't.
143                  */
144                 for (i = 1; i < blen; i++)
145                     if (b[i]) {
146                         pad = 1;
147                         pb = 0xFF;
148                         break;
149                     }
150             }
151         }
152         ret += pad;
153     }
154     if (pp == NULL)
155         return ret;
156     p = *pp;
157
158     if (pad)
159         *(p++) = pb;
160     if (blen == 0)
161         *(p++) = 0;
162     else if (!neg)
163         memcpy(p, b, blen);
164     else {
165         /* Begin at the end of the encoding */
166         n = b + blen - 1;
167         p += blen - 1;
168         i = blen;
169         /* Copy zeros to destination as long as source is zero */
170         while (!*n && i > 1) {
171             *(p--) = 0;
172             n--;
173             i--;
174         }
175         /* Complement and increment next octet */
176         *(p--) = ((*(n--)) ^ 0xff) + 1;
177         i--;
178         /* Complement any octets left */
179         for (; i > 0; i--)
180             *(p--) = *(n--) ^ 0xff;
181     }
182
183     *pp += ret;
184     return ret;
185 }
186
187 /*
188  * convert content octets into a big endian buffer. Returns the length
189  * of buffer or 0 on error: for malformed INTEGER. If output bufer is
190  * NULL just return length.
191  */
192
193 static size_t c2i_ibuf(unsigned char *b, int *pneg,
194                        const unsigned char *p, size_t plen)
195 {
196     size_t i;
197     int neg, pad;
198     /* Zero content length is illegal */
199     if (plen == 0) {
200         ASN1err(ASN1_F_C2I_IBUF, ASN1_R_ILLEGAL_ZERO_CONTENT);
201         return 0;
202     }
203     neg = p[0] & 0x80;
204     if (pneg)
205         *pneg = neg;
206     /* Handle common case where length is 1 octet separately */
207     if (plen == 1) {
208         if (b) {
209             if (neg)
210                 b[0] = (p[0] ^ 0xFF) + 1;
211             else
212                 b[0] = p[0];
213         }
214         return 1;
215     }
216     if (p[0] == 0 || p[0] == 0xFF)
217         pad = 1;
218     else
219         pad = 0;
220     /* reject illegal padding: first two octets MSB can't match */
221     if (pad && (neg == (p[1] & 0x80))) {
222         ASN1err(ASN1_F_C2I_IBUF, ASN1_R_ILLEGAL_PADDING);
223         return 0;
224     }
225     /* If positive just copy across */
226     if (neg == 0) {
227         if (b)
228             memcpy(b, p + pad, plen - pad);
229         return plen - pad;
230     }
231
232     if (neg && pad) {
233         /* check is any following octets are non zero */
234         for (i = 1; i < plen; i++) {
235             if (p[i] != 0)
236                 break;
237         }
238         /* if all bytes are zero handle as special case */
239         if (i == plen) {
240             if (b) {
241                 b[0] = 1;
242                 memset(b + 1, 0, plen - 1);
243             }
244             return plen;
245         }
246     }
247
248     plen -= pad;
249     /* Must be negative: calculate twos complement */
250     if (b) {
251         const unsigned char *from = p + plen - 1 + pad;
252         unsigned char *to = b + plen - 1;
253         i = plen;
254         while (*from == 0 && i) {
255             *to-- = 0;
256             i--;
257             from--;
258         }
259         *to-- = (*from-- ^ 0xff) + 1;
260         OPENSSL_assert(i != 0);
261         i--;
262         for (; i > 0; i--)
263             *to-- = *from-- ^ 0xff;
264     }
265     return plen;
266 }
267
268 int i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp)
269 {
270     return i2c_ibuf(a->data, a->length, a->type & V_ASN1_NEG, pp);
271 }
272
273 /* Convert big endian buffer into uint64_t, return 0 on error */
274 static int asn1_get_uint64(uint64_t *pr, const unsigned char *b, size_t blen)
275 {
276     size_t i;
277     if (blen > sizeof(*pr)) {
278         ASN1err(ASN1_F_ASN1_GET_UINT64, ASN1_R_TOO_LARGE);
279         return 0;
280     }
281     *pr = 0;
282     if (b == NULL)
283         return 0;
284     for (i = 0; i < blen; i++) {
285         *pr <<= 8;
286         *pr |= b[i];
287     }
288     return 1;
289 }
290
291 static size_t asn1_put_uint64(unsigned char *b, uint64_t r)
292 {
293     if (r >= 0x100) {
294         unsigned char *p;
295         uint64_t rtmp = r;
296         size_t i = 0;
297
298         /* Work out how many bytes we need */
299         while (rtmp) {
300             rtmp >>= 8;
301             i++;
302         }
303
304         /* Copy from end to beginning */
305         p = b + i - 1;
306
307         do {
308             *p-- = r & 0xFF;
309             r >>= 8;
310         } while (p >= b);
311
312         return i;
313     }
314
315     b[0] = (unsigned char)r;
316     return 1;
317
318 }
319
320 /*
321  * Absolute value of INT64_MIN: we can't just use -INT64_MIN as it produces
322  * overflow warnings.
323  */
324
325 #define ABS_INT64_MIN \
326     ((uint64_t)INT64_MAX + (uint64_t)(-(INT64_MIN + INT64_MAX)))
327
328 /* signed version of asn1_get_uint64 */
329 static int asn1_get_int64(int64_t *pr, const unsigned char *b, size_t blen,
330                           int neg)
331 {
332     uint64_t r;
333     if (asn1_get_uint64(&r, b, blen) == 0)
334         return 0;
335     if (neg) {
336         if (r > ABS_INT64_MIN) {
337             ASN1err(ASN1_F_ASN1_GET_INT64, ASN1_R_TOO_SMALL);
338             return 0;
339         }
340         *pr = (int64_t)-r;
341     } else {
342         if (r > INT64_MAX) {
343             ASN1err(ASN1_F_ASN1_GET_INT64, ASN1_R_TOO_LARGE);
344             return 0;
345         }
346         *pr = (int64_t)r;
347     }
348     return 1;
349 }
350
351 /* Convert ASN1 INTEGER content octets to ASN1_INTEGER structure */
352 ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
353                                long len)
354 {
355     ASN1_INTEGER *ret = NULL;
356     size_t r;
357     int neg;
358
359     r = c2i_ibuf(NULL, NULL, *pp, len);
360
361     if (r == 0)
362         return NULL;
363
364     if ((a == NULL) || ((*a) == NULL)) {
365         ret = ASN1_INTEGER_new();
366         if (ret == NULL)
367             return NULL;
368         ret->type = V_ASN1_INTEGER;
369     } else
370         ret = *a;
371
372     if (ASN1_STRING_set(ret, NULL, r) == 0)
373         goto err;
374
375     c2i_ibuf(ret->data, &neg, *pp, len);
376
377     if (neg)
378         ret->type |= V_ASN1_NEG;
379
380     *pp += len;
381     if (a != NULL)
382         (*a) = ret;
383     return ret;
384  err:
385     ASN1err(ASN1_F_C2I_ASN1_INTEGER, ERR_R_MALLOC_FAILURE);
386     if ((a == NULL) || (*a != ret))
387         ASN1_INTEGER_free(ret);
388     return NULL;
389 }
390
391 static int asn1_string_get_int64(int64_t *pr, const ASN1_STRING *a, int itype)
392 {
393     if (a == NULL) {
394         ASN1err(ASN1_F_ASN1_STRING_GET_INT64, ERR_R_PASSED_NULL_PARAMETER);
395         return 0;
396     }
397     if ((a->type & ~V_ASN1_NEG) != itype) {
398         ASN1err(ASN1_F_ASN1_STRING_GET_INT64, ASN1_R_WRONG_INTEGER_TYPE);
399         return 0;
400     }
401     return asn1_get_int64(pr, a->data, a->length, a->type & V_ASN1_NEG);
402 }
403
404 static int asn1_string_set_int64(ASN1_STRING *a, int64_t r, int itype)
405 {
406     unsigned char tbuf[sizeof(r)];
407     size_t l;
408     a->type = itype;
409     if (r < 0) {
410         l = asn1_put_uint64(tbuf, -r);
411         a->type |= V_ASN1_NEG;
412     } else {
413         l = asn1_put_uint64(tbuf, r);
414         a->type &= ~V_ASN1_NEG;
415     }
416     if (l == 0)
417         return 0;
418     return ASN1_STRING_set(a, tbuf, l);
419 }
420
421 /*
422  * This is a version of d2i_ASN1_INTEGER that ignores the sign bit of ASN1
423  * integers: some broken software can encode a positive INTEGER with its MSB
424  * set as negative (it doesn't add a padding zero).
425  */
426
427 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
428                                 long length)
429 {
430     ASN1_INTEGER *ret = NULL;
431     const unsigned char *p;
432     unsigned char *s;
433     long len;
434     int inf, tag, xclass;
435     int i;
436
437     if ((a == NULL) || ((*a) == NULL)) {
438         if ((ret = ASN1_INTEGER_new()) == NULL)
439             return (NULL);
440         ret->type = V_ASN1_INTEGER;
441     } else
442         ret = (*a);
443
444     p = *pp;
445     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
446     if (inf & 0x80) {
447         i = ASN1_R_BAD_OBJECT_HEADER;
448         goto err;
449     }
450
451     if (tag != V_ASN1_INTEGER) {
452         i = ASN1_R_EXPECTING_AN_INTEGER;
453         goto err;
454     }
455
456     /*
457      * We must OPENSSL_malloc stuff, even for 0 bytes otherwise it signifies
458      * a missing NULL parameter.
459      */
460     s = OPENSSL_malloc((int)len + 1);
461     if (s == NULL) {
462         i = ERR_R_MALLOC_FAILURE;
463         goto err;
464     }
465     ret->type = V_ASN1_INTEGER;
466     if (len) {
467         if ((*p == 0) && (len != 1)) {
468             p++;
469             len--;
470         }
471         memcpy(s, p, (int)len);
472         p += len;
473     }
474
475     OPENSSL_free(ret->data);
476     ret->data = s;
477     ret->length = (int)len;
478     if (a != NULL)
479         (*a) = ret;
480     *pp = p;
481     return (ret);
482  err:
483     ASN1err(ASN1_F_D2I_ASN1_UINTEGER, i);
484     if ((a == NULL) || (*a != ret))
485         ASN1_INTEGER_free(ret);
486     return (NULL);
487 }
488
489 static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
490                                       int atype)
491 {
492     ASN1_INTEGER *ret;
493     int len;
494
495     if (ai == NULL) {
496         ret = ASN1_STRING_type_new(atype);
497     } else {
498         ret = ai;
499         ret->type = atype;
500     }
501
502     if (ret == NULL) {
503         ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_NESTED_ASN1_ERROR);
504         goto err;
505     }
506
507     if (BN_is_negative(bn) && !BN_is_zero(bn))
508         ret->type |= V_ASN1_NEG_INTEGER;
509
510     len = BN_num_bytes(bn);
511
512     if (len == 0)
513         len = 1;
514
515     if (ASN1_STRING_set(ret, NULL, len) == 0) {
516         ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_MALLOC_FAILURE);
517         goto err;
518     }
519
520     /* Correct zero case */
521     if (BN_is_zero(bn))
522         ret->data[0] = 0;
523     else
524         len = BN_bn2bin(bn, ret->data);
525     ret->length = len;
526     return ret;
527  err:
528     if (ret != ai)
529         ASN1_INTEGER_free(ret);
530     return (NULL);
531 }
532
533 static BIGNUM *asn1_string_to_bn(const ASN1_INTEGER *ai, BIGNUM *bn,
534                                  int itype)
535 {
536     BIGNUM *ret;
537
538     if ((ai->type & ~V_ASN1_NEG) != itype) {
539         ASN1err(ASN1_F_ASN1_STRING_TO_BN, ASN1_R_WRONG_INTEGER_TYPE);
540         return NULL;
541     }
542
543     ret = BN_bin2bn(ai->data, ai->length, bn);
544     if (ret == 0) {
545         ASN1err(ASN1_F_ASN1_STRING_TO_BN, ASN1_R_BN_LIB);
546         return NULL;
547     }
548     if (ai->type & V_ASN1_NEG)
549         BN_set_negative(ret, 1);
550     return ret;
551 }
552
553 int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a)
554 {
555     return asn1_string_get_int64(pr, a, V_ASN1_INTEGER);
556 }
557
558 int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)
559 {
560     return asn1_string_set_int64(a, r, V_ASN1_INTEGER);
561 }
562
563 int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
564 {
565     return ASN1_INTEGER_set_int64(a, v);
566 }
567
568 long ASN1_INTEGER_get(const ASN1_INTEGER *a)
569 {
570     int i;
571     int64_t r;
572     if (a == NULL)
573         return 0;
574     i = ASN1_INTEGER_get_int64(&r, a);
575     if (i == 0)
576         return -1;
577     if (r > LONG_MAX || r < LONG_MIN)
578         return -1;
579     return (long)r;
580 }
581
582 ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
583 {
584     return bn_to_asn1_string(bn, ai, V_ASN1_INTEGER);
585 }
586
587 BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
588 {
589     return asn1_string_to_bn(ai, bn, V_ASN1_INTEGER);
590 }
591
592 int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a)
593 {
594     return asn1_string_get_int64(pr, a, V_ASN1_ENUMERATED);
595 }
596
597 int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r)
598 {
599     return asn1_string_set_int64(a, r, V_ASN1_ENUMERATED);
600 }
601
602 int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
603 {
604     return ASN1_ENUMERATED_set_int64(a, v);
605 }
606
607 long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a)
608 {
609     int i;
610     int64_t r;
611     if (a == NULL)
612         return 0;
613     if ((a->type & ~V_ASN1_NEG) != V_ASN1_ENUMERATED)
614         return -1;
615     if (a->length > (int)sizeof(long))
616         return 0xffffffffL;
617     i = ASN1_ENUMERATED_get_int64(&r, a);
618     if (i == 0)
619         return -1;
620     if (r > LONG_MAX || r < LONG_MIN)
621         return -1;
622     return (long)r;
623 }
624
625 ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai)
626 {
627     return bn_to_asn1_string(bn, ai, V_ASN1_ENUMERATED);
628 }
629
630 BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn)
631 {
632     return asn1_string_to_bn(ai, bn, V_ASN1_ENUMERATED);
633 }