Remove --classic build entirely
[openssl.git] / crypto / asn1 / a_int.c
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.]
56  */
57
58 #include <stdio.h>
59 #include "internal/cryptlib.h"
60 #include "internal/numbers.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 (b == NULL || 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 buffer 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 static int asn1_string_get_uint64(uint64_t *pr, const ASN1_STRING *a,
422                                   int itype)
423 {
424     if (a == NULL) {
425         ASN1err(ASN1_F_ASN1_STRING_GET_UINT64, ERR_R_PASSED_NULL_PARAMETER);
426         return 0;
427     }
428     if ((a->type & ~V_ASN1_NEG) != itype) {
429         ASN1err(ASN1_F_ASN1_STRING_GET_UINT64, ASN1_R_WRONG_INTEGER_TYPE);
430         return 0;
431     }
432     if (a->type & V_ASN1_NEG) {
433         ASN1err(ASN1_F_ASN1_STRING_GET_UINT64, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
434         return 0;
435     }
436     return asn1_get_uint64(pr, a->data, a->length);
437 }
438
439 static int asn1_string_set_uint64(ASN1_STRING *a, uint64_t r, int itype)
440 {
441     unsigned char tbuf[sizeof(r)];
442     size_t l;
443     a->type = itype;
444     l = asn1_put_uint64(tbuf, r);
445     if (l == 0)
446         return 0;
447     return ASN1_STRING_set(a, tbuf, l);
448 }
449
450 /*
451  * This is a version of d2i_ASN1_INTEGER that ignores the sign bit of ASN1
452  * integers: some broken software can encode a positive INTEGER with its MSB
453  * set as negative (it doesn't add a padding zero).
454  */
455
456 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
457                                 long length)
458 {
459     ASN1_INTEGER *ret = NULL;
460     const unsigned char *p;
461     unsigned char *s;
462     long len;
463     int inf, tag, xclass;
464     int i;
465
466     if ((a == NULL) || ((*a) == NULL)) {
467         if ((ret = ASN1_INTEGER_new()) == NULL)
468             return (NULL);
469         ret->type = V_ASN1_INTEGER;
470     } else
471         ret = (*a);
472
473     p = *pp;
474     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
475     if (inf & 0x80) {
476         i = ASN1_R_BAD_OBJECT_HEADER;
477         goto err;
478     }
479
480     if (tag != V_ASN1_INTEGER) {
481         i = ASN1_R_EXPECTING_AN_INTEGER;
482         goto err;
483     }
484
485     /*
486      * We must OPENSSL_malloc stuff, even for 0 bytes otherwise it signifies
487      * a missing NULL parameter.
488      */
489     s = OPENSSL_malloc((int)len + 1);
490     if (s == NULL) {
491         i = ERR_R_MALLOC_FAILURE;
492         goto err;
493     }
494     ret->type = V_ASN1_INTEGER;
495     if (len) {
496         if ((*p == 0) && (len != 1)) {
497             p++;
498             len--;
499         }
500         memcpy(s, p, (int)len);
501         p += len;
502     }
503
504     OPENSSL_free(ret->data);
505     ret->data = s;
506     ret->length = (int)len;
507     if (a != NULL)
508         (*a) = ret;
509     *pp = p;
510     return (ret);
511  err:
512     ASN1err(ASN1_F_D2I_ASN1_UINTEGER, i);
513     if ((a == NULL) || (*a != ret))
514         ASN1_INTEGER_free(ret);
515     return (NULL);
516 }
517
518 static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
519                                       int atype)
520 {
521     ASN1_INTEGER *ret;
522     int len;
523
524     if (ai == NULL) {
525         ret = ASN1_STRING_type_new(atype);
526     } else {
527         ret = ai;
528         ret->type = atype;
529     }
530
531     if (ret == NULL) {
532         ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_NESTED_ASN1_ERROR);
533         goto err;
534     }
535
536     if (BN_is_negative(bn) && !BN_is_zero(bn))
537         ret->type |= V_ASN1_NEG_INTEGER;
538
539     len = BN_num_bytes(bn);
540
541     if (len == 0)
542         len = 1;
543
544     if (ASN1_STRING_set(ret, NULL, len) == 0) {
545         ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_MALLOC_FAILURE);
546         goto err;
547     }
548
549     /* Correct zero case */
550     if (BN_is_zero(bn))
551         ret->data[0] = 0;
552     else
553         len = BN_bn2bin(bn, ret->data);
554     ret->length = len;
555     return ret;
556  err:
557     if (ret != ai)
558         ASN1_INTEGER_free(ret);
559     return (NULL);
560 }
561
562 static BIGNUM *asn1_string_to_bn(const ASN1_INTEGER *ai, BIGNUM *bn,
563                                  int itype)
564 {
565     BIGNUM *ret;
566
567     if ((ai->type & ~V_ASN1_NEG) != itype) {
568         ASN1err(ASN1_F_ASN1_STRING_TO_BN, ASN1_R_WRONG_INTEGER_TYPE);
569         return NULL;
570     }
571
572     ret = BN_bin2bn(ai->data, ai->length, bn);
573     if (ret == 0) {
574         ASN1err(ASN1_F_ASN1_STRING_TO_BN, ASN1_R_BN_LIB);
575         return NULL;
576     }
577     if (ai->type & V_ASN1_NEG)
578         BN_set_negative(ret, 1);
579     return ret;
580 }
581
582 int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a)
583 {
584     return asn1_string_get_int64(pr, a, V_ASN1_INTEGER);
585 }
586
587 int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)
588 {
589     return asn1_string_set_int64(a, r, V_ASN1_INTEGER);
590 }
591
592 int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a)
593 {
594     return asn1_string_get_uint64(pr, a, V_ASN1_INTEGER);
595 }
596
597 int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r)
598 {
599     return asn1_string_set_uint64(a, r, V_ASN1_INTEGER);
600 }
601
602 int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
603 {
604     return ASN1_INTEGER_set_int64(a, v);
605 }
606
607 long ASN1_INTEGER_get(const ASN1_INTEGER *a)
608 {
609     int i;
610     int64_t r;
611     if (a == NULL)
612         return 0;
613     i = ASN1_INTEGER_get_int64(&r, a);
614     if (i == 0)
615         return -1;
616     if (r > LONG_MAX || r < LONG_MIN)
617         return -1;
618     return (long)r;
619 }
620
621 ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
622 {
623     return bn_to_asn1_string(bn, ai, V_ASN1_INTEGER);
624 }
625
626 BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
627 {
628     return asn1_string_to_bn(ai, bn, V_ASN1_INTEGER);
629 }
630
631 int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a)
632 {
633     return asn1_string_get_int64(pr, a, V_ASN1_ENUMERATED);
634 }
635
636 int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r)
637 {
638     return asn1_string_set_int64(a, r, V_ASN1_ENUMERATED);
639 }
640
641 int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
642 {
643     return ASN1_ENUMERATED_set_int64(a, v);
644 }
645
646 long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a)
647 {
648     int i;
649     int64_t r;
650     if (a == NULL)
651         return 0;
652     if ((a->type & ~V_ASN1_NEG) != V_ASN1_ENUMERATED)
653         return -1;
654     if (a->length > (int)sizeof(long))
655         return 0xffffffffL;
656     i = ASN1_ENUMERATED_get_int64(&r, a);
657     if (i == 0)
658         return -1;
659     if (r > LONG_MAX || r < LONG_MIN)
660         return -1;
661     return (long)r;
662 }
663
664 ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai)
665 {
666     return bn_to_asn1_string(bn, ai, V_ASN1_ENUMERATED);
667 }
668
669 BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn)
670 {
671     return asn1_string_to_bn(ai, bn, V_ASN1_ENUMERATED);
672 }